<?xml version="1.0"?>
<doc>
    <assembly>
        <name>MiscUtil</name>
    </assembly>
    <members>
        <member name="T:MiscUtil.Threading.LockOrderException">
            <summary>
            Exception thrown when a Lock method on the SyncLock class times out.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.LockOrderException.#ctor(System.String)">
            <summary>
            Constructs an instance with the specified message.
            </summary>
            <param name="message">The message for the exception</param>
        </member>
        <member name="M:MiscUtil.Threading.LockOrderException.#ctor(System.String,System.Object[])">
            <summary>
            Constructs an instance by formatting the specified message with
            the given parameters.
            </summary>
            <param name="format">The message, which will be formatted with the parameters.</param>
            <param name="args">The parameters to use for formatting.</param>
        </member>
        <member name="T:MiscUtil.Threading.ExceptionHandler">
            <summary>
            Delegate for handling exceptions.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.ThreadPoolExceptionHandler">
            <summary>
            Delegate for handling exceptions thrown by work items executing
            in a custom thread pool.
            </summary>
            <param name="pool">The pool which created the worker thread</param>
            <param name="workItem">The work item which threw the exception</param>
            <param name="e">The exception thrown</param>
            <param name="handled">
            Whether or not the exception has been handled by this delegate. The value
            of this parameter will be false on entry, and changing it to true will
            prevent any further delegates in the event from being executed.
            </param>
        </member>
        <member name="T:MiscUtil.Threading.BeforeWorkItemHandler">
            <summary>
            Delegate for handling the event that a thread is about to execute
            a work item.
            </summary>
            <param name="pool">The pool which created the worker thread</param>
            <param name="workItem">The work item which is about to execute</param>
            <param name="cancel">
            Whether or not the work item should be cancelled. The value
            of this parameter will be false on entry, and changing it to true will
            prevent any further delegates in the event from being executed, and
            prevent the work item itself from being executed.
            </param>
        </member>
        <member name="T:MiscUtil.Threading.AfterWorkItemHandler">
            <summary>
            Delegate for handling the event that a thread has executed a work item.
            </summary>
            <param name="pool">The pool which created the worker thread</param>
            <param name="workItem">The work item which has executed</param>
        </member>
        <member name="T:MiscUtil.Threading.ThreadProgress">
            <summary>
            Delegate for handling the event that a thread has changed state
            (e.g. it's about to execute a work item, it's just executed one, etc).
            Also used for requests for a thread to change state (e.g. if a stop
            request has been received).
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.ControlledThreadStart">
            <summary>
            Represents the method that is executed by a ThreadController.
            </summary>
        </member>
        <member name="T:MiscUtil.Text.UnicodeRange">
            <summary>
            Utility class providing a number of singleton instances of
            Range&lt;char&gt; to indicate the various ranges of unicode characters,
            as documented at http://msdn.microsoft.com/en-us/library/20bw873z.aspx.
            Note that this does not indicate the Unicode category of a character,
            merely which range it's in.
            TODO: Work out how to include names. Can't derive from Range[char].
            </summary>
        </member>
        <member name="M:MiscUtil.Text.UnicodeRange.GetRange(System.Char)">
            <summary>
            Returns the unicode range containing the specified character.
            </summary>
            <param name="c">Character to look for</param>
            <returns>The unicode range containing the specified character, or null if the character
            is not in a unicode range.</returns>
        </member>
        <member name="T:MiscUtil.Linq.OrderedDataProducer`1">
            <summary>
            A DataProducer with ordering capabilities
            </summary><remarks>Note that this may cause data to be buffered</remarks>
            <typeparam name="T"></typeparam>
        </member>
        <member name="T:MiscUtil.Linq.IOrderedDataProducer`1">
            <summary>
            Ordered variant of IDataProducer; note that generally
            this will force data to be buffered until the sequence
            is complete.
            </summary>
            <seealso cref="T:MiscUtil.Linq.IDataProducer`1"/>
        </member>
        <member name="T:MiscUtil.Linq.IDataProducer`1">
            <summary>
            Interface to be implemented by sequences of data which have a "push"
            nature rather than "pull" - instead of the IEnumerable model of
            the client pulling data from the sequence, here the client registers
            an interest in the data being produced, and in the sequence reaching
            an end. The data producer than produces data whenever it wishes, and the
            clients can react. This allows other actions to occur between items being
            pulled, as well as multiple clients for the same sequence of data.
            </summary>
        </member>
        <member name="E:MiscUtil.Linq.IDataProducer`1.DataProduced">
            <summary>
            Event which is raised when an item of data is produced.
            This will not be raised after EndOfData has been raised.
            The parameter for the event is the 
            </summary>
        </member>
        <member name="E:MiscUtil.Linq.IDataProducer`1.EndOfData">
            <summary>
            Event which is raised when the sequence has finished being
            produced. This will be raised exactly once, and after all
            DataProduced events (if any) have been raised.
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.IOrderedDataProducer`1.BaseProducer">
            <summary>
            The unlerlying producer that can push data
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.IOrderedDataProducer`1.Comparer">
            <summary>
            The comparer used to order the sequence (once complete)
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.OrderedDataProducer`1.#ctor(MiscUtil.Linq.IDataProducer{`0},System.Collections.Generic.IComparer{`0})">
            <summary>
            Create a new OrderedDataProducer
            </summary>
            <param name="baseProducer">The base source which will supply data</param>
            <param name="comparer">The comparer to use when sorting the data (once complete)</param>
        </member>
        <member name="T:MiscUtil.Linq.Extensions.DataProducerExt">
            <summary>
            Extensions on IDataProducer
            </summary>
            <summary>
            Extensions on IDataProducer
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Where``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Filters a data-producer based on a predicate on each value
            </summary>
            <param name="source">The data-producer to be filtered</param>
            <param name="predicate">The condition to be satisfied</param>
            <returns>A filtered data-producer; only matching values will raise the DataProduced event</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Where``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int32,System.Boolean})">
            <summary>
            Filters a data-producer based on a predicate on each value; the index
            in the sequence is used in the predicate
            </summary>
            <param name="source">The data-producer to be filtered</param>
            <param name="predicate">The condition to be satisfied</param>
            <returns>A filtered data-producer; only matching values will raise the DataProduced event</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.DefaultIfEmpty``1(MiscUtil.Linq.IDataProducer{``0},``0)">
            <summary>
            Returns a data-producer that yeilds the values from the sequence, or which yields the given
            singleton value if no data is produced.
            </summary>
            <param name="defaultValue">The default value to be yielded if no data is produced.</param>
            <param name="source">The source data-producer.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.DefaultIfEmpty``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a data-producer that yeilds the values from the sequence, or which yields the default
            value for the Type if no data is produced.
            </summary>
            <param name="source">The source data-producer.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Select``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Returns a projection on the data-producer, using a transformation to
            map each element into a new form.
            </summary>
            <typeparam name="TSource">The source type</typeparam>
            <typeparam name="TResult">The projected type</typeparam>
            <param name="source">The source data-producer</param>
            <param name="projection">The transformation to apply to each element.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Select``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int32,``1})">
            <summary>
            Returns a projection on the data-producer, using a transformation
            (involving the elements's index in the sequence) to
            map each element into a new form.
            </summary>
            <typeparam name="TSource">The source type</typeparam>
            <typeparam name="TResult">The projected type</typeparam>
            <param name="source">The source data-producer</param>
            <param name="projection">The transformation to apply to each element.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Take``1(MiscUtil.Linq.IDataProducer{``0},System.Int32)">
            <summary>
            Returns a data-producer that will yield a specified number of
            contiguous elements from the start of a sequence - i.e.
            "the first &lt;x&gt; elements".
            </summary>
            <param name="source">The source data-producer</param>
            <param name="count">The maximum number of elements to return</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Skip``1(MiscUtil.Linq.IDataProducer{``0},System.Int32)">
            <summary>
            Returns a data-producer that will ignore a specified number of
            contiguous elements from the start of a sequence, and yield
            all elements after this point - i.e. 
            "elements from index &lt;x&gt; onwards".
            </summary>
            <param name="source">The source data-producer</param>
            <param name="count">The number of elements to ignore</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.TakeWhile``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a data-producer that will yield
            elements a sequence as long as a condition
            is satsified; when the condition fails for an element,
            that element and all subsequent elements are ignored.
            </summary>
            <param name="source">The source data-producer</param>
            <param name="predicate">The condition to yield elements</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.TakeWhile``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int32,System.Boolean})">
            <summary>
            Returns a data-producer that will yield
            elements a sequence as long as a condition
            (involving the element's index in the sequence)
            is satsified; when the condition fails for an element,
            that element and all subsequent elements are ignored.
            </summary>
            <param name="source">The source data-producer</param>
            <param name="predicate">The condition to yield elements</param>        
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.SkipWhile``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a data-producer that will ignore the
            elements from the start of a sequence while a condition
            is satsified; when the condition fails for an element,
            that element and all subsequent elements are yielded.
            </summary>
            <param name="source">The source data-producer</param>
            <param name="predicate">The condition to skip elements</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.SkipWhile``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int32,System.Boolean})">
            <summary>
            Returns a data-producer that will ignore the
            elements from the start of a sequence while a condition
            (involving the elements's index in the sequence)
            is satsified; when the condition fails for an element,
            that element and all subsequent elements are yielded.
            </summary>
            <param name="source">The source data-producer</param>
            <param name="predicate">The condition to skip elements</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Distinct``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a data-producer that yields the first instance of each unique
            value in the sequence; subsequent identical values are ignored.
            </summary>
            <param name="source">The data-producer</param>
            <remarks>This will force the first instance of each unique value to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Distinct``1(MiscUtil.Linq.IDataProducer{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Returns a data-producer that yields the first instance of each unique
            value in the sequence; subsequent identical values are ignored.
            </summary>
            <param name="source">The data-producer</param>
            <param name="comparer">Used to determine equaility between values</param>
            <remarks>This will force the first instance of each unique value to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Reverse``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Reverses the order of a sequence
            </summary>
            <param name="source">The data-producer</param>
            <returns>A data-producer that yields the sequence
            in the reverse order</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ThenBy``2(MiscUtil.Linq.IOrderedDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Further orders the values from an ordered data-source by a transform on each term, ascending
            (the sort operation is only applied once for the combined ordering)
            </summary>
            <param name="source">The original data-producer and ordering</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ThenBy``2(MiscUtil.Linq.IOrderedDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Further orders the values from an ordered data-source by a transform on each term, ascending
            (the sort operation is only applied once for the combined ordering)
            </summary>
            <param name="source">The original data-producer and ordering</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <param name="comparer">Comparer to compare the selected values</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ThenByDescending``2(MiscUtil.Linq.IOrderedDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Further orders the values from an ordered data-source by a transform on each term, descending
            (the sort operation is only applied once for the combined ordering)
            </summary>
            <param name="source">The original data-producer and ordering</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ThenByDescending``2(MiscUtil.Linq.IOrderedDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Further orders the values from an ordered data-source by a transform on each term, descending
            (the sort operation is only applied once for the combined ordering)
            </summary>
            <param name="source">The original data-producer and ordering</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <param name="comparer">Comparer to compare the selected values</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>        
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.OrderBy``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Orders the values from a data-source by a transform on each term, ascending
            </summary>
            <param name="source">The original data-producer</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.OrderBy``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Orders the values from a data-source by a transform on each term, ascending
            </summary>
            <param name="source">The original data-producer</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <param name="comparer">Comparer to compare the selected values</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.OrderByDescending``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Orders the values from a data-source by a transform on each term, descending
            </summary>
            <param name="source">The original data-producer</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.OrderByDescending``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Orders the values from a data-source by a transform on each term, descending
            </summary>
            <param name="source">The original data-producer</param>
            <param name="selector">Returns the value (for each term) by which to order the sequence</param>
            <param name="comparer">Comparer to compare the selected values</param>
            <returns>A data-producer that yeilds the sequence ordered
            by the selected value</returns>
            <remarks>This will force all data to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Count``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns the number of elements in a sequence, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">A sequence that contains elements to be counted.</param>
            <returns>The number of elements in the input sequence, as a future value.
            The actual count can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Count``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns the number of elements in the specified sequence satisfy a condition,
            as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">A sequence that contains elements to be tested and counted.</param>
            <param name="predicate">A function to test each element for a condition.</param>
            <returns>A number that represents how many elements in the sequence satisfy 
            the condition in the predicate function, as a future value.
            The actual count can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.LongCount``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns the number of elements in a sequence, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">A sequence that contains elements to be counted.</param>
            <returns>The number of elements in the input sequence, as a future value.
            The actual count can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.LongCount``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns the number of elements in the specified sequence satisfy a condition,
            as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">A sequence that contains elements to be tested and counted.</param>
            <param name="predicate">A function to test each element for a condition.</param>
            <returns>A number that represents how many elements in the sequence satisfy 
            the condition in the predicate function, as a future value.
            The actual count can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.First``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns the first element of a sequence, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">The sequence to return the first element of.</param>
            <returns>The first element in the specified sequence, as a future value.
            The actual value can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.First``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns the first element in a sequence that satisfies a specified condition, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">The sequence to an element from.</param>
            <param name="predicate">A function to test each element for a condition.</param>
            <returns>The first element in the specified sequence that passes the test in 
            the specified predicate function, as a future value.
            The actual value can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Last``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns the last element of a sequence, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">The sequence to return the last element of.</param>
            <returns>The last element in the specified sequence, as a future value.
            The actual value can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Last``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns the last element in a sequence that satisfies a specified condition, as a future value.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <param name="source">The sequence to an element from.</param>
            <param name="predicate">A function to test each element for a condition.</param>
            <returns>The last element in the specified sequence that passes the test in 
            the specified predicate function, as a future value.
            The actual value can only be retrieved after the source has indicated the end
            of its data.
            </returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.FirstOrDefault``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the first value from a sequence, or the default for that type
            if no value is produced.
            </summary>
            <param name="source">The source data-producer.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.FirstOrDefault``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a future to the first value from a sequence that matches the given condition, or the default
            for that type if no matching value is produced.
            </summary>
            <param name="source">The source data-producer.</param>
            <param name="predicate">The condition to be satisfied.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.LastOrDefault``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the last value from a sequence, or the default for that type
            if no value is produced.
            </summary>
            <param name="source">The source data-producer.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.LastOrDefault``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns the last value from a sequence that matches the given condition, or the default
            for that type if no matching value is produced.
            </summary>
            <param name="source">The source data-producer.</param>
            <param name="predicate">The condition to be satisfied.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Single``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to a single value from a data-source; an exception
            is thrown if no values, or multiple values, are encountered.
            </summary>
            <param name="source">The source data-producer.</param>
            <exception cref="T:System.InvalidOperationException">Zero or multiple terms are encountered.</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Single``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a future to a single value from a data-source that matches the
            specified condition; an exception
            is thrown if no matching values, or multiple matching values, are encountered.
            </summary>
            <param name="source">The source data-producer.</param>
            <param name="predicate">The condition to be satisfied.</param>
            <exception cref="T:System.InvalidOperationException">Zero or multiple matching terms are encountered.</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.SingleOrDefault``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to a single value from a data-source or the default value if no values
            are encountered. An exception
            is thrown if multiple values are encountered.
            </summary>
            <param name="source">The source data-producer.</param>
            <exception cref="T:System.InvalidOperationException">Multiple terms are encountered.</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.SingleOrDefault``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a future to a single value from a data-source that matches the
            specified condition, or the default value if no matching values
            are encountered. An exception
            is thrown if multiple matching values are encountered.
            </summary>
            <param name="source">The source data-producer.</param>
            <param name="predicate">The condition to be satisfied.</param>
            <exception cref="T:System.InvalidOperationException">Multiple matching terms are encountered.</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ElementAt``1(MiscUtil.Linq.IDataProducer{``0},System.Int32)">
            <summary>
            Returns a future to the element at the given position in the sequence
            </summary>
            <param name="source">The data-producer</param>
            <param name="index">The index of the desired trem in the sequence</param>
            <exception cref="T:System.ArgumentOutOfRangeException">If the specified index is negative
            or is never reached</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ElementAtOrDefault``1(MiscUtil.Linq.IDataProducer{``0},System.Int32)">
            <summary>
            Returns a future to the element at the given position in the sequence,
            or the default-value if the specified index is never reached
            </summary>
            <param name="source">The data-producer</param>
            <param name="index">The index of the desired trem in the sequence</param>
            <exception cref="T:System.ArgumentOutOfRangeException">If the specified index is negative</exception>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.All``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a future that indicates whether all values
            yielded by the data-producer satisfy a given condition.
            The future will return true for an empty sequence or
            where all values satisfy the condition, else false
            (if any value value fails to satisfy the condition).
            </summary>
            <param name="source">The data-producer to be monitored.</param>
            <param name="predicate">The condition that must be satisfied by all terms.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Any``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future that indicates whether any values are
            yielded by the data-producer. The future will return false
            for an empty sequence, or true for a sequence with values.
            </summary>
            <param name="source">The data-producer to be monitored.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Any``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a future that indicates whether any suitable values are
            yielded by the data-producer. The future will return false
            for an empty sequence or one with no matching values, or true for a sequence with matching values.
            </summary>
            <param name="source">The data-producer to be monitored.</param>
            <param name="predicate">The condition that must be satisfied.</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Contains``1(MiscUtil.Linq.IDataProducer{``0},``0)">
            <summary>
            Returns a future to indicate whether the specified value
            is yielded by the data-source.
            </summary>
            <typeparam name="TSource">The type of data to be yielded</typeparam>
            <param name="source">The data-source</param>
            <param name="value">The value to detect from the data-source, checked with the default comparer</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Contains``1(MiscUtil.Linq.IDataProducer{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Returns a future to indicate whether the specified value
            is yielded by the data-source.
            </summary>
            <typeparam name="TSource">The type of data to be yielded</typeparam>
            <param name="source">The data-source</param>
            <param name="value">The value to detect from the data-source</param>
            <param name="comparer">The comparer to use to determine equality</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Aggregate``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``0,``0})">
            <summary>
            Applies an accumulator function over the values yielded from
            a data-producer. The first value in the seqnence
            is used as the initial accumulator value, and the specified function is used
            to select the result value. If the sequence is empty then
            the default value for TSource is returned.
            </summary>
            <typeparam name="TSource">The type of data yielded by the data-source</typeparam>
            <param name="func">Accumulator function to be applied to each term in the sequence</param>
            <param name="source">The data-source for the values</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Aggregate``2(MiscUtil.Linq.IDataProducer{``0},``1,System.Func{``1,``0,``1})">
            <summary>
            Applies an accumulator function over the values yielded from
            a data-producer. The specified seed value
            is used as the initial accumulator value, and the specified function is used
            to select the result value
            </summary>
            <typeparam name="TSource">The type of data yielded by the data-source</typeparam>
            <typeparam name="TAccumulate">The type to be used for the accumulator</typeparam>
            <param name="func">Accumulator function to be applied to each term in the sequence</param>
            <param name="seed">The initial value for the accumulator</param>
            <param name="source">The data-source for the values</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Aggregate``3(MiscUtil.Linq.IDataProducer{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})">
            <summary>
            Applies an accumulator function over the values yielded from
            a data-producer, performing a transformation on the final
            accululated value. The specified seed value
            is used as the initial accumulator value, and the specified function is used
            to select the result value
            </summary>
            <typeparam name="TSource">The type of data yielded by the data-source</typeparam>
            <typeparam name="TResult">The final result type (after the accumulator has been transformed)</typeparam>
            <typeparam name="TAccumulate">The type to be used for the accumulator</typeparam>
            <param name="func">Accumulator function to be applied to each term in the sequence</param>
            <param name="resultSelector">Transformation to apply to the final
            accumulated value to produce the result</param>
            <param name="seed">The initial value for the accumulator</param>
            <param name="source">The data-source for the values</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Sum``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Returns a future to the sum of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
            <remarks>Null values are removed from the sum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Sum``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the sum of a sequence of values
            </summary>
            <remarks>Null values are removed from the sum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Returns a future to the average of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the average of a sequence of values
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average(MiscUtil.Linq.IDataProducer{System.Int32})">
            <summary>
            Returns a future to the average of a sequence of values
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average(MiscUtil.Linq.IDataProducer{System.Nullable{System.Int32}})">
            <summary>
            Returns a future to the average of a sequence of values
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average(MiscUtil.Linq.IDataProducer{System.Int64})">
            <summary>
            Returns a future to the average of a sequence of values
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average(MiscUtil.Linq.IDataProducer{System.Nullable{System.Int64}})">
            <summary>
            Returns a future to the average of a sequence of values
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int32})">
            <summary>
            Returns a future to the average of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Nullable{System.Int32}})">
            <summary>
            Returns a future to the average of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Int64})">
            <summary>
            Returns a future to the average of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Average``1(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,System.Nullable{System.Int64}})">
            <summary>
            Returns a future to the average of a sequence of values that are
            obtained by taking a transform of the input sequence
            </summary>
            <remarks>Null values are removed from the average</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Max``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Returns a future to the maximum of a sequence of values that are
            obtained by taking a transform of the input sequence, using the default comparer, using the default comparer
            </summary>
            <remarks>Null values are removed from the maximum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Max``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the maximum of a sequence of values, using the default comparer
            </summary>
            <remarks>Null values are removed from the maximum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Min``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Returns a future to the minumum of a sequence of values that are
            obtained by taking a transform of the input sequence, using the default comparer
            </summary>
            <remarks>Null values are removed from the minimum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.Min``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Returns a future to the minumum of a sequence of values, using the default comparer
            </summary>
            <remarks>Null values are removed from the minimum</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.AsFutureEnumerable``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Converts an IDataProducer into an IFuture[IEnumerable]. The results
            are buffered in memory (as a list), so be warned that this loses the "streaming"
            nature of most of the IDataProducer extension methods. The "future" nature of
            the result ensures that all results are produced before the enumeration can take
            place.
            </summary>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.AsEnumerable``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Converts an IDataProducer into an IEnumerable. The results
            are buffered in memory (as a list), so be warned that this loses the "streaming"
            nature of most of the IDataProducer extension methods. The list is returned
            immediately, but further data productions add to it. You must therefore be careful
            when the list is used - it is a good idea to only use it after all data has been
            produced.
            </summary>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToList``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Converts an IDataProducer into a list. An empty list is returned immediately,
            and any results produced are added to it.
            </summary>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToFutureArray``1(MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Converts an IDataProducer into a future array.
            </summary>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToLookup``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Converts an IDataProducer into a lookup.
            </summary>
            <param name="elementSelector">A transform function to produce a result element value from each element.</param>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="keyComparer">Used to compare keys.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToLookup``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Converts an IDataProducer into a lookup.
            </summary>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToLookup``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Converts an IDataProducer into a lookup.
            </summary>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="keyComparer">Used to compare keys.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToLookup``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2})">
            <summary>
            Converts an IDataProducer into a lookup.
            </summary>
            <param name="elementSelector">A transform function to produce a result element value from each element.</param>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToDictionary``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Converts an IDataProducer into a dictionary.
            </summary>
            <param name="elementSelector">A transform function to produce a result element value from each element.</param>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="keyComparer">Used to compare keys.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToDictionary``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Converts an IDataProducer into a dictionary.
            </summary>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToDictionary``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Converts an IDataProducer into a dictionary.
            </summary>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="keyComparer">Used to compare keys.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.ToDictionary``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2})">
            <summary>
            Converts an IDataProducer into a dictionary.
            </summary>
            <param name="elementSelector">A transform function to produce a result element value from each element.</param>
            <param name="keySelector">A function to extract a key from each element.</param>
            <param name="source">The data source.</param>
            <remarks>This will force all values to be buffered</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key.
            </summary>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``2(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key.
            </summary>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="comparer">Used to compare grouping keys</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key. The elements of each
            group are projected by using a specified function.
            </summary>
            <typeparam name="TElement">The return-type of the transform used to process the
            values within each grouping.</typeparam>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="elementSelector">A function to map each source element to an element in the appropriate group</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``1,MiscUtil.Linq.IDataProducer{``0},``2})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key.
            </summary>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TResult">The final values to be yielded after processing</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="resultSelector">A function to create a result value from each group.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key. The elements of each
            group are projected by using a specified function.
            </summary>
            <typeparam name="TElement">The return-type of the transform used to process the
            values within each grouping.</typeparam>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="comparer">Used to compare grouping keys</param>
            <param name="elementSelector">A function to map each source element to an element in the appropriate group</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``4(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,MiscUtil.Linq.IDataProducer{``2},``3})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key. The elements of each
            group are projected by using a specified function.
            </summary>
            <typeparam name="TElement">The return-type of the transform used to process the
            values within each grouping.</typeparam>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TResult">The final values to be yielded after processing</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="elementSelector">A function to map each source element to an element in the appropriate group</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="resultSelector">A function to create a result value from each group.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``3(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``1,MiscUtil.Linq.IDataProducer{``0},``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key.
            </summary>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TResult">The final values to be yielded after processing</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="comparer">Used to compare grouping keys</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="resultSelector">A function to create a result value from each group.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.DataProducerExt.GroupBy``4(MiscUtil.Linq.IDataProducer{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``1,MiscUtil.Linq.IDataProducer{``2},``3},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the elements of a sequence according to a specified key selector function
            and creates a result value from each group and its key. The elements of each
            group are projected by using a specified function.
            </summary>
            <typeparam name="TElement">The return-type of the transform used to process the
            values within each grouping.</typeparam>
            <typeparam name="TKey">The return-type of the transform used to group the sequence</typeparam>
            <typeparam name="TResult">The final values to be yielded after processing</typeparam>
            <typeparam name="TSource">The values to be yielded by the original data-source</typeparam>
            <param name="comparer">Used to compare grouping keys</param>
            <param name="elementSelector">A function to map each source element to an element in the appropriate group</param>
            <param name="keySelector">A function to extract the key for each element in hte original sequence.</param>
            <param name="resultSelector">A function to create a result value from each group.</param>
            <param name="source">The data-source to be grouped</param>
            <remarks>This will force each unique grouping key to
            be buffered, but not the data itself</remarks>
        </member>
        <member name="T:MiscUtil.Linq.EditableLookup`2">
            <summary>
            Simple non-unique map wrapper
            </summary>
            <remarks>
            ApplyResultSelector (from Lookup[TKey, TElement] is not implemented,
            since the caller could just as easily (or more-so) use .Select() with
            a Func[IGrouping[TKey, TElement], TResult], since
            IGrouping[TKey, TElement] already includes both the "TKey Key"
            and the IEnumerable[TElement].
            </remarks>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.#ctor">
            <summary>
            Creates a new EditableLookup using the default key-comparer
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Creates a new EditableLookup using the specified key-comparer
            </summary>
            <param name="keyComparer"></param>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.Contains(`0)">
            <summary>
            Does the lookup contain any value(s) for the given key?
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.Contains(`0,`1)">
            <summary>
            Does the lookup the specific key/value pair?
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.Add(`0,`1)">
            <summary>
            Adds a key/value pair to the lookup
            </summary>
            <remarks>If the value is already present it will be duplicated</remarks>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.AddRange(`0,System.Collections.Generic.IEnumerable{`1})">
            <summary>
            Adds a range of values against a single key
            </summary>
            <remarks>Any values already present will be duplicated</remarks>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.AddRange(System.Linq.ILookup{`0,`1})">
            <summary>
            Add all key/value pairs from the supplied lookup
            to the current lookup
            </summary>
            <remarks>Any values already present will be duplicated</remarks>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.Remove(`0)">
            <summary>
            Remove all values from the lookup for the given key
            </summary>
            <returns>True if any items were removed, else false</returns>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.Remove(`0,`1)">
            <summary>
            Remove the specific key/value pair from the lookup
            </summary>
            <returns>True if the item was found, else false</returns>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.TrimExcess">
            <summary>
            Trims the inner data-structure to remove
            any surplus space
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.EditableLookup`2.GetEnumerator">
            <summary>
            Returns the sequence of keys and their contained values
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.EditableLookup`2.Count">
            <summary>
            Returns the number of dictinct keys in the lookup
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.EditableLookup`2.Item(`0)">
            <summary>
            Returns the set of values for the given key
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.Extensions.RangeBasedExt">
            <summary>
            Extension methods to do with ranges.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.RangeBasedExt.To``1(``0,``0)">
            <summary>
            Creates an inclusive range between two values. The default comparer is used
            to compare values.
            </summary>
            <typeparam name="T">Type of the values</typeparam>
            <param name="start">Start of range.</param>
            <param name="end">End of range.</param>
            <returns>An inclusive range between the start point and the end point.</returns>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.RangeBasedExt.StepChar(MiscUtil.Collections.Range{System.Char},System.Int32)">
            <summary>
            Returns a RangeIterator over the given range, where the stepping function
            is to step by the given number of characters.
            </summary>
            <param name="range">The range to create an iterator for</param>
            <param name="step">How many characters to step each time</param>
            <returns>A RangeIterator with a suitable stepping function</returns>
        </member>
        <member name="T:MiscUtil.CachedBuffer">
            <summary>
            Type of buffer returned by CachingBufferManager.
            </summary>
        </member>
        <member name="T:MiscUtil.IBuffer">
            <summary>
            Interface encapsulating a byte array which may be managed
            by an IBufferManager implementation. When the buffer is
            disposed, some implementations of this interface may
            return the buffer to the IBufferManager which created
            it. Note that an IBuffer *must* always be disposed after use,
            or some implementations may leak memory. The buffer must
            not be used after being disposed, likewise the byte array must
            not be used after the buffer is disposed.
            </summary>
        </member>
        <member name="P:MiscUtil.IBuffer.Bytes">
            <summary>
            Returns the byte array encapsulated by this buffer.
            Note that depending on the buffer manager providing
            the buffer, the array may or may not be cleared (i.e.
            with every byte 0) to start with.
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.Instruction">
            <summary>
            Contains the information for a single instruction
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.RandomAccessQueue`1">
            <summary>
            A class with a similar function to System.Collections.Queue,
            but allowing random access to the contents of the queue as well
            as the usual enqueuing at the end and dequeuing at the start.
            This implementation is not synchronized at all - clients should
            provide their own synchronization. A SyncRoot is provided for
            this purpose, although any other common reference may also be used.
            In order to provide an efficient implementation of both random access
            and the removal of items from the start of the queue, a circular
            buffer is used and resized when necessary. The buffer never shrinks
            unless TrimToSize is called.
            </summary>
        </member>
        <member name="F:MiscUtil.Collections.RandomAccessQueue`1.DefaultCapacity">
            <summary>
            Default (and minimum) capacity for the buffer containing the elements in the queue.
            </summary>
        </member>
        <member name="F:MiscUtil.Collections.RandomAccessQueue`1.buffer">
            <summary>
            The circular buffer containing the items in the queue
            </summary>
        </member>
        <member name="F:MiscUtil.Collections.RandomAccessQueue`1.start">
            <summary>
            The "physical" index of item with logical index 0.
            </summary>
        </member>
        <member name="F:MiscUtil.Collections.RandomAccessQueue`1.version">
            <summary>
            Version information for the queue - this is incremented every time
            the contents of the queue is changed, so that enumerators can detect
            the change.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of the RandomAccessQueue class which is empty
            and has the specified capacity (or the default capacity if that is higher).
            </summary>
            <param name="capacity">The initial capacity of the queue</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.#ctor">
            <summary>
            Initializes a new instance of the RandomAccessQueue class which is empty
            and has the default capacity.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.#ctor(`0[],System.Int32,System.Int32)">
            <summary>
            Private constructor used in cloning
            </summary>
            <param name="buffer">The buffer to clone for use in this queue</param>
            <param name="count">The number of "valid" elements in the buffer</param>
            <param name="start">The first valid element in the queue</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Clear">
            <summary>
            Clears the queue without resizing the buffer
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.TrimToSize">
            <summary>
            Resizes the buffer to just fit the current number of items in the queue.
            The buffer size is never set to less than the default capacity, however.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Enqueue(`0)">
            <summary>
            Adds an item to the end of the queue.
            </summary>
            <param name="value">The item to add to the queue. The value can be a null reference.</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Enqueue(`0,System.Int32)">
            <summary>
            Adds an object at the specified index.
            </summary>
            <param name="value">The item to add to the queue. The value can be a null reference.</param>
            <param name="index">The index of the newly added item</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Dequeue">
            <summary>
            Removes an T from the start of the queue, returning it.
            </summary>
            <returns>The item at the head of the queue</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.RemoveAt(System.Int32)">
            <summary>
            Removes an item at the given index and returns it.
            </summary>
            <param name="index">The index of the item to remove</param>
            <returns>The item which has been removed from the</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.CopyTo(System.Array,System.Int32)">
            <summary>
            Copies the elements of the queue to the given array, beginning at
            the specified index in the array.
            </summary>
            <param name="dest">The array to copy the contents of the queue into</param>
            <param name="index">The zero-based index in array at which copying begins</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.BinarySearch(`0)">
            <summary>
            Performs a binary search using IComparable. If the value occurs multiple times,
            there is no guarantee as to which index will be returned. If the value does
            not occur at all, the bitwise complement of the first index containing a larger
            value is returned (or the bitwise complement of the size of the queue if the value
            is larger than any value in the queue). This is the location at which the value should
            be inserted to preserve sort order. If the list is not sorted according to 
            the appropriate IComparable implementation before this method is calling, the result
            is not guaranteed. The value passed in must implement IComparable, unless it is null.
            The IComparable.CompareTo method will be called on the value passed in, with the
            values in the queue as parameters, rather than the other way round. No test is made
            to make sure that the types of item are the same - it is up to the implementation of
            IComparable to throw an exception if incomparable types are presented.
            A null reference is treated as being less than any item, (so passing in null will always 
            return 0 or -1). The implementation of IComparable is never asked to compare to null.
            </summary>
            <param name="obj">The item to search for</param>
            <returns>
            A location in the queue containing the item, or the bitwise complement of the 
            first index containing a larger value.
            </returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.BinarySearch(`0,System.Collections.Generic.IComparer{`0})">
            <summary>
            Performs a binary search using the specified IComparer. If the value occurs multiple times,
            there is no guarantee as to which index will be returned. If the value does
            not occur at all, the bitwise complement of the first index containing a larger
            value is returned (or the bitwise complement of the size of the queue if the value
            is larger than any value in the queue). This is the location at which the value should
            be inserted to preserve sort order. If the list is not sorted according to 
            the appropriate IComparer implementation before this method is calling, the result
            is not guaranteed. The CompareTo method will be called on the comparer passed in, with the
            specified value as the first parameter, and values in the queue as the second parameter, 
            rather than the other way round.
            While a null reference should be treated as being less than any object in most
            implementations of IComparer, this is not required by this method. Any null references
            (whether in the queue or the specified value itself) are passed directly to the CompareTo
            method. This allow for IComparers to reverse the usual order, if required.
            </summary>
            <param name="obj">The object to search for</param>
            <param name="comparer">The comparator to use for searching. Must not be null.</param>
            <returns>
            A location in the queue containing the object, or the bitwise complement of the 
            first index containing a larger value.
            </returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.BinarySearch(`0,System.Comparison{`0})">
            <summary>
            Performs a binary search using the specified Comparison. If the value occurs multiple times,
            there is no guarantee as to which index will be returned. If the value does
            not occur at all, the bitwise complement of the first index containing a larger
            value is returned (or the bitwise complement of the size of the queue if the value
            is larger than any value in the queue). This is the location at which the value should
            be inserted to preserve sort order. If the list is not sorted according to 
            the appropriate IComparer implementation before this method is calling, the result
            is not guaranteed. The CompareTo method will be called on the comparer passed in, with the
            specified value as the first parameter, and values in the queue as the second parameter, 
            rather than the other way round.
            While a null reference should be treated as being less than any object in most
            implementations of IComparer, this is not required by this method. Any null references
            (whether in the queue or the specified value itself) are passed directly to the CompareTo
            method. This allow for Comparisons to reverse the usual order, if required.
            </summary>
            <param name="obj">The object to search for</param>
            <param name="comparison">The comparison to use for searching. Must not be null.</param>
            <returns>
            A location in the queue containing the object, or the bitwise complement of the 
            first index containing a larger value.
            </returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.GetEnumerator">
            <summary>
            Returns an enumerator that can iterate through the queue.
            Note that due to the way C# 2.0 iterators work, we cannot spot changes 
            to the queue after the enumerator was fetched but before MoveNext() is first
            called.
            </summary>
            <returns>Returns an enumerator for the entire queue.</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Returns an enumerator that can iterate through the queue.
            </summary>
            <returns>Returns an enumerator for the entire queue.</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.System#ICloneable#Clone">
            <summary>
            Creates a new queue with the same contents as this queue.
            The queues are separate, however - adding an item to the returned
            queue doesn't affect the current queue or vice versa.
            A new sync root is also supplied.
            </summary>
            <returns>A clone of the current queue</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Clone">
            <summary>
            Strongly typed version of ICloneable.Clone. Creates a new queue 
            with the same contents as this queue.
            The queues are separate, however - adding an item to the returned
            queue doesn't affect the current queue or vice versa.
            A new sync root is also supplied.
            </summary>
            <returns>A clone of the current queue</returns>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Resize(System.Int32,System.Int32)">
            <summary>
            Resizes the queue to a new capacity, optionally leaving a gap at
            a specified logical index so that a new item can be slotted in 
            without further copying
            </summary>
            <param name="newCapacity">The new capacity</param>
            <param name="gapIndex">The logical index at which to insert a gap,
            or -1 for no gap</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Add(`0)">
            <summary>
            Adds an item to the queue
            </summary>
            <param name="item">The item to add</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Contains(`0)">
            <summary>
            Returns whether or not the queue contains the given item,
            using the default EqualityComparer if the item to find is
            non-null.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copies the elements of the queue to the given array, beginning at
            the specified index in the array.
            </summary>
            <param name="dest">The array to copy the contents of the queue into</param>
            <param name="index">The zero-based index in array at which copying begins</param>
        </member>
        <member name="M:MiscUtil.Collections.RandomAccessQueue`1.Remove(`0)">
            <summary>
            Removes the given item from the queue, if it is present. The first
            equal value is removed.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.Count">
            <summary>
            The number of items in the queue.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.Item(System.Int32)">
            <summary>
            Indexer for the class, allowing items to be retrieved by
            index and replaced.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.Capacity">
            <summary>
            Current capacity of the queue - the size of the buffer.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.SyncRoot">
            <summary>
            An object reference to synchronize on when using the queue
            from multiple threads. This reference isn't used anywhere
            in the class itself. The same reference will always be returned
            for the same queue, and this will never be the same as the reference
            returned for a different queue, even a clone.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.IsSynchronized">
            <summary>
            Returns false, to indicate that this queue is not synchronized.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RandomAccessQueue`1.IsReadOnly">
            <summary>
            Returns false, to indicate that this queue is not read-only.
            </summary>
        </member>
        <member name="T:MiscUtil.Checksum.Adler32">
            <summary>
            Implementation of the Adler32 checksum routine.
            TODO: Derive from HashAlgorithm.
            </summary>
        </member>
        <member name="F:MiscUtil.Checksum.Adler32.Base">
            <summary>
            Base for modulo arithmetic
            </summary>
        </member>
        <member name="F:MiscUtil.Checksum.Adler32.NMax">
            <summary>
            Number of iterations we can safely do before applying the modulo.
            </summary>
        </member>
        <member name="M:MiscUtil.Checksum.Adler32.ComputeChecksum(System.Int32,System.Byte[],System.Int32,System.Int32)">
            <summary>
            Computes the Adler32 checksum for the given data.
            </summary>
            <param name="initial">
            Initial value or previous result. Use 1 for the
            first transformation.
            </param>
            <param name="data">The data to compute the checksum of</param>
            <param name="start">Index of first byte to compute checksum for</param>
            <param name="length">Number of bytes to compute checksum for</param>
            <returns>The checksum of the given data</returns>
        </member>
        <member name="M:MiscUtil.Checksum.Adler32.ComputeChecksum(System.Int32,System.Byte[])">
            <summary>
            Computes the Adler32 checksum for the given data.
            </summary>
            <param name="initial">
            Initial value or previous result. Use 1 for the
            first transformation.
            </param>
            <param name="data">The data to compute the checksum of</param>
            <returns>The checksum of the given data</returns>
        </member>
        <member name="M:MiscUtil.Checksum.Adler32.ComputeChecksum(System.IO.Stream)">
            <summary>
            Computes the checksum for a stream, starting from the current
            position and reading until no more can be read
            </summary>
            <param name="stream">The stream to compute the checksum for</param>
            <returns>The checksum for the stream</returns>
        </member>
        <member name="M:MiscUtil.Checksum.Adler32.ComputeChecksum(System.String)">
            <summary>
            Computes the checksum of a file
            </summary>
            <param name="path">The file to compute the checksum of</param>
            <returns>The checksum for the file</returns>
        </member>
        <member name="T:MiscUtil.Threading.ThreadPoolWorkItem">
            <summary>
            Class encapsulating an item of work to be executed in a CustomThreadPool.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.ThreadPoolWorkItem.#ctor(System.Object,System.Boolean,System.Boolean,System.Int32,System.Delegate,System.Object[])">
            <summary>
            Creates a new instance of this class.
            </summary>
            <param name="id">The ID of the work item. May be null.</param>
            <param name="preserveParameters">
            Whether or not the parameter array should be preserved during the work item's
            execution to allow the information to be retrieved in the WorkerException and
            AfterWorkItem events.
            </param>
            <param name="cloneParameters">
            Whether or not the parameter array provided should be cloned. This should be
            true if the contents of the passed array will be changed by the caller afterwards,
            but false in the common case of creating the array solely for the purpose of
            constructing this work item. Note that the values within the array are not cloned
            - just the array itself.
            </param>
            <param name="priority">The priority of this work item.</param>
            <param name="target">
            The delegate to run when the work item is executed. Must not be null.
            </param>
            <param name="parameters">
            The parameters to pass to the target delegate. May be null if the delegate
            takes no parameters.
            </param>
        </member>
        <member name="M:MiscUtil.Threading.ThreadPoolWorkItem.#ctor(System.Delegate,System.Object[])">
            <summary>
            Creates a new work item with the given target delegate and parameters.
            The parameters (if any) are cloned on construction and preserved during
            the work item's execution. The ID of the constructed work item is null,
            and the priority is 0.
            </summary>
            <param name="target">
            The delegate to run when the work item is executed. Must not be null.
            </param>
            <param name="parameters">
            The parameters to pass to the target delegate. May be null if the delegate
            takes no parameters.
            </param>
        </member>
        <member name="M:MiscUtil.Threading.ThreadPoolWorkItem.Invoke">
            <summary>
            Invokes the work item.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadPoolWorkItem.Target">
            <summary>
            The target delegate for the work item. This is the delegate
            which is run when the work item is executed.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadPoolWorkItem.Parameters">
            <summary>
            The parameters passed to the delegate. This may be null,
            and will definitely be null if PreserveParameters is false
            and the work item has started executing. The contents of
            the returned array should not be changed.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadPoolWorkItem.Priority">
            <summary>
            The priority of this work item compared with others. Note
            that this is entirely independent of the thread priority - it
            serves only to specify the order of execution of a work item.
            Items with a higher priority are added ahead of items with a lower
            priority in the queue.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadPoolWorkItem.PreserveParameters">
            <summary>
            Whether or not to preserve parameters during and after
            execution. If this is true, the parameters are available in
            the AfterWorkItem and WorkerException events of the containing
            CustomThreadPool. However, this means that the contents cannot 
            be garbage collected until after the work item has finished
            executing, which may be costly in some situations.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadPoolWorkItem.ID">
            <summary>
            The ID of the work item, which may be null. This is provided
            by the caller when the work item is constructed, and is used
            for cancellation purposes.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.ProducerGrouping`2">
            <summary>
            Simple implementation of IProducerGrouping which proxies to an existing
            IDataProducer.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.IProducerGrouping`2">
            <summary>
            IProducerGrouping is to IDataProducer as IGrouping is to IEnumerable:
            it's basically a data producer with a key. It's used by the GroupBy
            operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.IProducerGrouping`2.Key">
            <summary>
            The key for this grouping.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.ProducerGrouping`2.#ctor(`0,MiscUtil.Linq.IDataProducer{`1})">
            <summary>
            Constructs a new grouping with the given key
            </summary>
        </member>
        <member name="E:MiscUtil.Linq.ProducerGrouping`2.DataProduced">
            <summary>
            Event which is raised when an item of data is produced.
            This will not be raised after EndOfData has been raised.
            The parameter for the event is the 
            </summary>
            <seealso cref="E:MiscUtil.Linq.IDataProducer`1.DataProduced"/>
        </member>
        <member name="E:MiscUtil.Linq.ProducerGrouping`2.EndOfData">
            <summary>
            Event which is raised when the sequence has finished being
            produced. This will be raised exactly once, and after all
            DataProduced events (if any) have been raised.
            </summary>
            <seealso cref="E:MiscUtil.Linq.IDataProducer`1.EndOfData"/>
        </member>
        <member name="P:MiscUtil.Linq.ProducerGrouping`2.Key">
            <summary>
            The key for this grouping.
            </summary>
        </member>
        <member name="T:MiscUtil.IO.StringWriterWithEncoding">
            <summary>
            A simple class derived from StringWriter, but which allows
            the user to select which Encoding is used. This is most
            likely to be used with XmlTextWriter, which uses the Encoding
            property to determine which encoding to specify in the XML.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.StringWriterWithEncoding.encoding">
            <summary>
            The encoding to return in the Encoding property.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.StringWriterWithEncoding.#ctor(System.Text.Encoding)">
            <summary>
            Initializes a new instance of the StringWriterWithEncoding class
            with the specified encoding.
            </summary>
            <param name="encoding">The encoding to report.</param>
        </member>
        <member name="M:MiscUtil.IO.StringWriterWithEncoding.#ctor(System.IFormatProvider,System.Text.Encoding)">
            <summary>
            Initializes a new instance of the StringWriter class with the 
            specified format control and encoding.
            </summary>
            <param name="formatProvider">An IFormatProvider object that controls formatting.</param>
            <param name="encoding">The encoding to report.</param>
        </member>
        <member name="M:MiscUtil.IO.StringWriterWithEncoding.#ctor(System.Text.StringBuilder,System.Text.Encoding)">
            <summary>
            Initializes a new instance of the StringWriter class that writes to the
            specified StringBuilder, and reports the specified encoding.
            </summary>
            <param name="sb">The StringBuilder to write to. </param>
            <param name="encoding">The encoding to report.</param>
        </member>
        <member name="M:MiscUtil.IO.StringWriterWithEncoding.#ctor(System.Text.StringBuilder,System.IFormatProvider,System.Text.Encoding)">
            <summary>
            Initializes a new instance of the StringWriter class that writes to the specified 
            StringBuilder, has the specified format provider, and reports the specified encoding.
            </summary>
            <param name="sb">The StringBuilder to write to. </param>
            <param name="formatProvider">An IFormatProvider object that controls formatting.</param>
            <param name="encoding">The encoding to report.</param>
        </member>
        <member name="P:MiscUtil.IO.StringWriterWithEncoding.Encoding">
            <summary>
            Gets the Encoding in which the output is written.
            </summary>
        </member>
        <member name="T:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt">
            <summary>
            Extension methods producing TimeSpan values. Note: Ticks should really
            take a long, and the rest should all take doubles. It looks like extension
            methods don't quite work properly with implicit numeric conversions :(
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Ticks(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of ticks.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Milliseconds(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of milliseconds.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Seconds(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of seconds.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Minutes(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of minutes.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Hours(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of hours.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.TimeSpanBasedExt.Days(System.Int32)">
            <summary>
            Returns a TimeSpan representing the specified number of days.
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.AddressCache">
            <summary>
            Cache used for encoding/decoding addresses.
            </summary>
        </member>
        <member name="T:MiscUtil.BufferAcquisitionException">
            <summary>
            Exception thrown to indicate that a buffer of the
            desired size cannot be acquired.
            </summary>
        </member>
        <member name="M:MiscUtil.BufferAcquisitionException.#ctor(System.String)">
            <summary>
            Creates an instance of this class with the given message.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.LockToken">
            <summary>
            A lock token returned by a Lock method call on a SyncLock.
            This effectively holds the lock until it is disposed - a 
            slight violation of the IDisposable contract, but it makes
            for easy use of the SyncLock system. This type itself
            is not thread-safe - LockTokens should not be shared between
            threads.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.LockToken.parent">
            <summary>
            The lock this token has been created by.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.LockToken.#ctor(MiscUtil.Threading.SyncLock)">
            <summary>
            Constructs a new lock token for the specified lock.
            </summary>
            <param name="parent">The internal monitor used for locking.</param>
        </member>
        <member name="M:MiscUtil.Threading.LockToken.Dispose">
            <summary>
            Releases the lock. Subsequent calls to this method do nothing.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.CustomThreadPool">
            <summary>
            A thread pool implementation which allows policy decisions
            for the number of threads to run, etc, to be programatically set.
            </summary>
            <remarks>
            Each instance runs with entirely separate threads, so one thread pool
            cannot "starve" another one of threads, although having lots of threads
            running may mean that some threads are starved of processor time.
            If the values for properties such as MinThreads, IdlePeriod etc are changed
            after threads have been started, it may take some time before their effects
            are noticed. For instance, reducing the idle time from 5 minutes to 1 minute
            will not prevent a thread which had only just started to idle from waiting
            for 5 minutes before dying. Any exceptions thrown in the work item itself
            are handled by the WorkerException event, but all other exceptions are
            propagated to the AppDomain's UnhandledException event. This includes
            exceptions thrown by the BeforeWorkItem and AfterWorkItem events.
            This class is thread-safe - any thread may call any method on any instance of it.
            </remarks>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.DefaultIdlePeriod">
            <summary>
            Default idle period for new pools
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.DefaultMinThreads">
            <summary>
            Default min threads for new pools
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.DefaultMaxThreads">
            <summary>
            Default max threads for new pools
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.MinWaitPeriod">
            <summary>
            If the idle period is short but we have less than the
            minimum number of threads, idle for this long instead,
            so as to avoid tight-looping. We don't enforce this
            minimum if the thread will die if it idles for its IdlePeriod.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.MaxWaitPeriod">
            <summary>
            If the idle period is long (or infinite) then we shouldn't
            actually wait that long, just in case the timeout etc changes.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.staticLock">
            <summary>
            Lock around all static members.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.instanceCount">
            <summary>
            Total number of instances created
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.#ctor">
            <summary>
            Creates a new thread pool with an autogenerated name.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.#ctor(System.String)">
            <summary>
            Creates a new thread pool with the specified name
            </summary>
            <param name="name">The name of the new thread pool</param>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.stateLock">
            <summary>
            Lock around access to all state other than events and the queue.
            The queue lock may be acquired within this lock.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.queueLock">
            <summary>
            Lock for the queue itself. The state lock must not be acquired within
            this lock unless it is already held by the thread.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.queue">
            <summary>
            The queue itself.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.threadCounter">
            <summary>
            The number of threads started (in total) by this threadpool.
            Used for naming threads.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.SetMinMaxThreads(System.Int32,System.Int32)">
            <summary>
            Sets both the minimum and maximum number of threads, atomically. This prevents
            exceptions which might occur when setting properties individually (e.g. going
            from (min=5, max=10) to (min=15, max=20), if the minimum were changed first,
            an exception would occur.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.eventLock">
            <summary>
            Lock around all access to events.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.OnException(MiscUtil.Threading.ThreadPoolWorkItem,System.Exception)">
            <summary>
            Raises the WorkerException event.
            TODO: Write to the event log if no exception handlers are attached?
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.beforeWorkItem">
            <summary>
            Delegate for the BeforeWorkItem event.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.OnBeforeWorkItem(MiscUtil.Threading.ThreadPoolWorkItem,System.Boolean@)">
            <summary>
            Raises the BeforeWorkItem event
            </summary>
            <param name="workItem">The work item which is about to execute</param>
            <param name="cancel">Whether or not the work item was cancelled by an event handler</param>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.afterWorkItem">
            <summary>
            Delegate for the AfterWorkItem event.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.OnAfterWorkItem(MiscUtil.Threading.ThreadPoolWorkItem)">
            <summary>
            Raises the AfterWorkItem event
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.workerThreadExit">
            <summary>
            Delegate for the ThreadExit event.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.OnWorkerThreadExit">
            <summary>
            Raises the WorkerThreadExit event and decrements the number of total worker threads
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.StartMinThreads">
            <summary>
            Ensures that the pool has at least the minimum number of threads.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.AddWorkItem(System.Delegate,System.Object[])">
            <summary>
            Adds a work item to the queue, starting a new thread if appropriate.
            </summary>
            <param name="workItemDelegate">The delegate representing the work item</param>
            <param name="parameters">The parameters to pass to the delegate</param>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.AddWorkItem(System.Delegate)">
            <summary>
            Adds a work item to the queue, starting a new thread if appropriate.
            </summary>
            <param name="workItemDelegate">The delegate representing the work item.</param>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.AddWorkItem(MiscUtil.Threading.ThreadPoolWorkItem)">
            <summary>
            Adds a work item to the queue and potentially start a new thread.
            A thread is started if there are no idle threads or if there is already
            something on the queue - but in each case, only if the total number of
            threads is less than the maximum.
            </summary>
            <param name="workItem">The actual work item to add to the queue.</param>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.CancelWorkItem(System.Object)">
            <summary>
            Cancels the first work item with the specified ID, if there is one.
            Note that items which have been taken off the queue and are running
            or about to be started cannot be cancelled.
            </summary>
            <param name="id">The ID of the work item to cancel</param>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.CancelAllWorkItems">
            <summary>
            Cancels all work items in the queue.
            Note that items which have been taken off the queue and are running
            or about to be started cannot be cancelled.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.StartWorkerThread">
            <summary>
            Starts a new worker thread.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.WorkerThreadLoop">
            <summary>
            Main worker thread loop. This picks jobs off the queue and executes
            them, until it's time to die.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.CalculateWaitPeriod(System.DateTime)">
            <summary>
            Work out how long to wait for in this iteration. If the thread isn't going
            to die even if the wait completes, make the idle timeout at least MinWaitPeriod
            so we don't end up with lots of threads stealing CPU by checking too often.
            </summary>
            <param name="lastJob">The time this thread last finished executing a work item.</param>
            <returns></returns>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.GetNextWorkItem(System.Int32)">
            <summary>
            Retrieves the next work item from the queue, pausing for at most
            the specified amount of time.
            </summary>
            <param name="waitPeriod">
            The maximum amount of time to wait for a work item to arrive, in ms.
            </param>
            <returns>
            The next work item, or null if there aren't any after waiting
            for the specified period.
            </returns>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.CheckIfThreadShouldQuit(System.DateTime)">
            <summary>
            Checks whether or not this thread should exit, based on the current number
            of threads and the time that this thread last finished executing a work item.
            </summary>
            <param name="lastJob">The time this thread last finished executing a work item.</param>
            <returns>Whether or not the thread is "spare" and should thus quit</returns>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.ExecuteWorkItem(MiscUtil.Threading.ThreadPoolWorkItem)">
            <summary>
            Executes the given work item, firing the BeforeWorkItem and AfterWorkItem events,
            and incrementing and decrementing the number of working threads.
            </summary>
            <param name="job">The work item to execute</param>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.IdlePeriod">
            <summary>
            How long a thread may be remain idle for before dying, in ms.
            Note that a thread will not die if doing so would
            reduce the number of threads below MinThreads. A value of 0 here
            indicates that threads should not idle at all (except if the number
            of threads would otherwise fall below MinThreads). A value of
            Timeout.Infinite indicates that a thread will idle until a new work item
            is added, however long that is.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.Name">
            <summary>
            Gets the name of the thread pool.
            This is used to set the name of any new threads created by the pool.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.MinThreads">
            <summary>
            The minimum number of threads to leave in the pool. Note that
            the pool may contain fewer threads than this until work items
            have been placed on the queue. A call to StartMinThreads
            will make sure that at least MinThreads threads have been started.
            This value must be non-negative. Note that a MinThreads value of 0
            introduces a possible (although very unlikely) race condition where
            a work item may be added to the queue just as the last thread decides
            to exit. In this case, the work item would not be executed until the
            next work item was added.
            TODO: Try to remove this race condition
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.MaxThreads">
            <summary>
            The maximum number of threads to allow to be in the pool at any
            one time. This value must be greater than or equal to 1.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.QueueLength">
            <summary>
            The number of work items currently awaiting execution.
            This does not include work items currently being executed.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.WorkingThreads">
            <summary>
            The number of threads currently executing work items
            or BeforeWorkItem/AfterWorkItem/WorkerException events.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.TotalThreads">
            <summary>
            The total number of threads in the pool at the present time.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.WorkerThreadPriority">
            <summary>
            The priority of worker threads. Each thread's priority is set
            before the BeforeWorkItem event and after the AfterWorkItem event.
            The priority of an individual thread may be changed in 
            the BeforeWorkItem event, and that changed priority
            will remain active for the duration of the work item itself.
            The default is ThreadPriority.Normal.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.CustomThreadPool.WorkerThreadsAreBackground">
            <summary>
            Whether or not worker threads should be created and
            set as background threads. This is set for the thread before
            the BeforeWorkItem event and after the AfterWorkItem event.
            The background status of a thread may be changed in the BeforeWorkItem
            event, and that changed status will remain active for the duration
            of the work item itself. Default is true.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.CustomThreadPool.WorkerException">
            <summary>
            Event which is fired if a worker thread throws an exception in
            its work item.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.CustomThreadPool.BeforeWorkItem">
            <summary>
            Event fired before a worker thread starts a work item.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.CustomThreadPool.AfterWorkItem">
            <summary>
            Event fired after a worker thread successfully finishes a work item.
            This event is not fired if the work item throws an exception.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.CustomThreadPool.WorkerThreadExit">
            <summary>
            Event called just before a thread dies.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.CustomThreadPool.PriorityComparer">
            <summary>
            Comparer which compares an integer priority with the priority of a work item.
            Must only be used in the appropriate order (CompareTo(int, WorkItem)). Also,
            0 is never returned by the method - effectively, the given priority is raised by
            0.5, so that when a binary search is used, the value is never found but the returned
            index is always the bitwise complement of the correct insertion point.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.CustomThreadPool.PriorityComparer.Instance">
            <summary>
            Access to single instance of PriorityComparer.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.PriorityComparer.#ctor">
            <summary>
            Private constructor to prevent instantiation
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.CustomThreadPool.PriorityComparer.Compare(MiscUtil.Threading.ThreadPoolWorkItem,MiscUtil.Threading.ThreadPoolWorkItem)">
            <summary>
            Implementation of IComparer.Compare - see class remarks for details.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.ExpressionUtil">
            <summary>
            General purpose Expression utilities
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.ExpressionUtil.CreateExpression``2(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.UnaryExpression})">
            <summary>
            Create a function delegate representing a unary operation
            </summary>
            <typeparam name="TArg1">The parameter type</typeparam>
            <typeparam name="TResult">The return type</typeparam>
            <param name="body">Body factory</param>
            <returns>Compiled function delegate</returns>
        </member>
        <member name="M:MiscUtil.Linq.ExpressionUtil.CreateExpression``3(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.BinaryExpression})">
            <summary>
            Create a function delegate representing a binary operation
            </summary>
            <typeparam name="TArg1">The first parameter type</typeparam>
            <typeparam name="TArg2">The second parameter type</typeparam>
            <typeparam name="TResult">The return type</typeparam>
            <param name="body">Body factory</param>
            <returns>Compiled function delegate</returns>
        </member>
        <member name="M:MiscUtil.Linq.ExpressionUtil.CreateExpression``3(System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.BinaryExpression},System.Boolean)">
            <summary>
            Create a function delegate representing a binary operation
            </summary>
            <param name="castArgsToResultOnFailure">
            If no matching operation is possible, attempt to convert
            TArg1 and TArg2 to TResult for a match? For example, there is no
            "decimal operator /(decimal, int)", but by converting TArg2 (int) to
            TResult (decimal) a match is found.
            </param>
            <typeparam name="TArg1">The first parameter type</typeparam>
            <typeparam name="TArg2">The second parameter type</typeparam>
            <typeparam name="TResult">The return type</typeparam>
            <param name="body">Body factory</param>
            <returns>Compiled function delegate</returns>
        </member>
        <member name="T:MiscUtil.Linq.Extensions.ListExt">
            <summary>
            Provides extension methods to List&lt;T&gt;
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.ListExt.Sort``2(System.Collections.Generic.List{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},System.Boolean)">
            <summary>
            Sorts the elements in the entire System.Collections.Generic.List{T} using
            a projection.
            </summary>
            <param name="source">Data source</param>
            <param name="selector">The projection to use to obtain values for comparison</param>
            <param name="comparer">The comparer to use to compare projected values (on null to use the default comparer)</param>
            <param name="descending">Should the list be sorted ascending or descending?</param>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.ListExt.Sort``2(System.Collections.Generic.List{``0},System.Func{``0,``1})">
            <summary>
            Sorts the elements in the entire System.Collections.Generic.List{T} using
            a projection.
            </summary>
            <param name="source">Data source</param>
            <param name="selector">The projection to use to obtain values for comparison</param>
        </member>
        <member name="T:MiscUtil.IO.NonClosingStreamWrapper">
            <summary>
            Wraps a stream for all operations except Close and Dispose, which
            merely flush the stream and prevent further operations from being
            carried out using this wrapper.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.#ctor(System.IO.Stream)">
            <summary>
            Creates a new instance of the class, wrapping the specified stream.
            </summary>
            <param name="stream">The stream to wrap. Must not be null.</param>
            <exception cref="T:System.ArgumentNullException">stream is null</exception>
        </member>
        <member name="F:MiscUtil.IO.NonClosingStreamWrapper.closed">
            <summary>
            Whether this stream has been closed or not
            </summary>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.CheckClosed">
            <summary>
            Throws an InvalidOperationException if the wrapper is closed.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
            <summary>
            Begins an asynchronous read operation.
            </summary>
            <param name="buffer">The buffer to read the data into. </param>
            <param name="offset">
            The byte offset in buffer at which to begin writing data read from the stream.
            </param>
            <param name="count">The maximum number of bytes to read. </param>
            <param name="callback">
            An optional asynchronous callback, to be called when the read is complete.
            </param>
            <param name="state">
            A user-provided object that distinguishes this particular 
            asynchronous read request from other requests.
            </param>
            <returns>
            An IAsyncResult that represents the asynchronous read, 
            which could still be pending.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.BeginWrite(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)">
            <summary>
            Begins an asynchronous write operation.
            </summary>
            <param name="buffer">The buffer to write data from.</param>
            <param name="offset">The byte offset in buffer from which to begin writing.</param>
            <param name="count">The maximum number of bytes to write.</param>
            <param name="callback">
            An optional asynchronous callback, to be called when the write is complete.
            </param>
            <param name="state">
            A user-provided object that distinguishes this particular asynchronous 
            write request from other requests.
            </param>
            <returns>
            An IAsyncResult that represents the asynchronous write, 
            which could still be pending.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.Close">
            <summary>
            This method is not proxied to the underlying stream; instead, the wrapper
            is marked as unusable for other (non-close/Dispose) operations. The underlying
            stream is flushed if the wrapper wasn't closed before this call.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.CreateObjRef(System.Type)">
            <summary>
            Throws a NotSupportedException.
            </summary>
            <param name="requestedType">The Type of the object that the new ObjRef will reference.</param>
            <returns>n/a</returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.EndRead(System.IAsyncResult)">
            <summary>
            Waits for the pending asynchronous read to complete.
            </summary>
            <param name="asyncResult">
            The reference to the pending asynchronous request to finish.
            </param>
            <returns>
            The number of bytes read from the stream, between zero (0) 
            and the number of bytes you requested. Streams only return 
            zero (0) at the end of the stream, otherwise, they should 
            block until at least one byte is available.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.EndWrite(System.IAsyncResult)">
            <summary>
            Ends an asynchronous write operation.
            </summary>
            <param name="asyncResult">A reference to the outstanding asynchronous I/O request.</param>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.Flush">
            <summary>
            Flushes the underlying stream.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.InitializeLifetimeService">
            <summary>
            Throws a NotSupportedException.
            </summary>
            <returns>n/a</returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads a sequence of bytes from the underlying stream and advances the 
            position within the stream by the number of bytes read.
            </summary>
            <param name="buffer">
            An array of bytes. When this method returns, the buffer contains 
            the specified byte array with the values between offset and 
            (offset + count- 1) replaced by the bytes read from the underlying source.
            </param>
            <param name="offset">
            The zero-based byte offset in buffer at which to begin storing the data 
            read from the underlying stream.
            </param>
            <param name="count">
            The maximum number of bytes to be read from the 
            underlying stream.
            </param>
            <returns>The total number of bytes read into the buffer. 
            This can be less than the number of bytes requested if that many 
            bytes are not currently available, or zero (0) if the end of the 
            stream has been reached.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.ReadByte">
            <summary>
            Reads a byte from the stream and advances the position within the 
            stream by one byte, or returns -1 if at the end of the stream.
            </summary>
            <returns>The unsigned byte cast to an Int32, or -1 if at the end of the stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
            Sets the position within the current stream.
            </summary>
            <param name="offset">A byte offset relative to the origin parameter.</param>
            <param name="origin">
            A value of type SeekOrigin indicating the reference 
            point used to obtain the new position.
            </param>
            <returns>The new position within the underlying stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.SetLength(System.Int64)">
            <summary>
            Sets the length of the underlying stream.
            </summary>
            <param name="value">The desired length of the underlying stream in bytes.</param>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Writes a sequence of bytes to the underlying stream and advances 
            the current position within the stream by the number of bytes written.
            </summary>
            <param name="buffer">
            An array of bytes. This method copies count bytes 
            from buffer to the underlying stream.
            </param>
            <param name="offset">
            The zero-based byte offset in buffer at 
            which to begin copying bytes to the underlying stream.
            </param>
            <param name="count">The number of bytes to be written to the underlying stream.</param>
        </member>
        <member name="M:MiscUtil.IO.NonClosingStreamWrapper.WriteByte(System.Byte)">
            <summary>
            Writes a byte to the current position in the stream and
            advances the position within the stream by one byte.
            </summary>
            <param name="value">The byte to write to the stream. </param>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.BaseStream">
            <summary>
            Stream wrapped by this wrapper
            </summary>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.CanRead">
            <summary>
            Indicates whether or not the underlying stream can be read from.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.CanSeek">
            <summary>
            Indicates whether or not the underlying stream supports seeking.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.CanWrite">
            <summary>
            Indicates whether or not the underlying stream can be written to.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.Length">
            <summary>
            Returns the length of the underlying stream.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.NonClosingStreamWrapper.Position">
            <summary>
            Gets or sets the current position in the underlying stream.
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.VcdiffFormatException">
            <summary>
            Summary description for VcdiffFormatException.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.ThreadController">
            <summary>
            Class designed to control a worker thread (co-operatively).
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.ThreadController.stateLock">
            <summary>
            Lock used throughout for all state management.
            (This is unrelated to the "state" variable.)
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.ThreadController.starter">
            <summary>
            The delegate to be invoked when the thread is started.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.ThreadController.state">
            <summary>
            State to pass to the "starter" delegate when the thread is started.
            This reference is discarded when the new thread is started, so
            it won't prevent garbage collection.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.#ctor(MiscUtil.Threading.ControlledThreadStart,System.Object)">
            <summary>
            Creates a new controller.
            </summary>
            <param name="starter">The delegate to invoke when the thread is started.
            Must not be null.</param>
            <param name="state">The state to pass to the delegate. May be null.</param>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.#ctor(MiscUtil.Threading.ControlledThreadStart)">
            <summary>
            Creates a new controller without specifying a state object to
            pass when the delegate is invoked.
            </summary>
            <param name="starter">The delegate to invoke when the thread is started.</param>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.CreateThread">
            <summary>
            Creates the thread to later be started. This enables
            properties of the thread to be manipulated before the thread
            is started.
            </summary>
            <exception cref="T:System.InvalidOperationException">The thread has already been created.</exception>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.Start">
            <summary>
            Starts the task in a separate thread, creating it if it hasn't already been
            created with the CreateThread method.
            </summary>
            <exception cref="T:System.InvalidOperationException">The thread has already been started.</exception>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.Stop">
            <summary>
            Tell the thread being controlled by this controller to stop. 
            This call does not throw an exception if the thread hasn't been 
            created, or has already been told to stop - it is therefore safe 
            to call at any time, regardless of other information about the 
            state of the controller. Depending on the way in which the controlled
            thread is running, it may not take notice of the request to stop
            for some time.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.ThreadController.RunTask">
            <summary>
            Runs the task specified by starter, catching exceptions and propagating them
            to the Exception event.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadController.Started">
            <summary>
            Whether the thread has been started. A thread can only
            be started once.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadController.Thread">
            <summary>
            Thread being controlled. May be null if it hasn't
            been created yet.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.ThreadController.Stopping">
            <summary>
            Whether or not the thread is stopping. This may be used
            by the thread itself to test whether or not to stop, as
            well as by clients checking status. To see whether the
            thread has actually finished or not, use the IsAlive
            property of the thread itself.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.ThreadController.Exception">
            <summary>
            Event raised if the controlled thread throws an unhandled exception.
            The exception is not propagated beyond the controller by default, however
            by adding an ExceptionHandler which simply rethrows the exception,
            it will propagate. Note that in this case any further ExceptionHandlers
            added after the propagating one will not be executed. This event is
            raised in the worker thread.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.ThreadController.Finished">
            <summary>
            Event raised when the thread has finished and all exception handlers
            have executed (if an exception was raised). Note that this event is
            raised even if one of the exception handlers propagates the exception
            up to the top level. This event is raised in the worker thread.
            </summary>
        </member>
        <member name="E:MiscUtil.Threading.ThreadController.StopRequested">
            <summary>
            Event raised when a stop is requested. Worker threads
            may register for this event to allow them to respond to
            stop requests in a timely manner. The event is raised
            in the thread which calls the Stop method.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.Extensions.EnumerableExt">
            <summary>
            Further extensions to IEnumerable{T}.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}})">
            <summary>
            Groups and executes a pipeline for a single result per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}})">
            <summary>
            Groups and executes a pipeline for a single result per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}})">
            <summary>
            Groups and executes a pipeline for two results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``4(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}})">
            <summary>
            Groups and executes a pipeline for two results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``5(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``4}})">
            <summary>
            Groups and executes a pipeline for three results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``5(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``4}})">
            <summary>
            Groups and executes a pipeline for three results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``6(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``4}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``5}})">
            <summary>
            Groups and executes a pipeline for four results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.GroupWithPipeline``6(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``2}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``3}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``4}},System.Func{MiscUtil.Linq.IDataProducer{``0},MiscUtil.Linq.IFuture{``5}})">
            <summary>
            Groups and executes a pipeline for four results per group
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Sum``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the sum of a sequence of values
            </summary>
            <remarks>The values in the sequence must support the Add operator</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Sum``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Computes the sum of the sequence of values that are
            obtained by invoking a transform function on each element of the input sequence.
            </summary>
            <remarks>The values returned by the transform function must support the Add operator</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Average``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Computes the mean average of a sequence of values
            </summary>
            <remarks>The values in the sequence must support the Add and Divide(Int32) operators</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Average``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Computes the mean average of the sequence of values that are
            obtained by invoking a transform function on each element of the input sequence.
            </summary>
            <remarks>The values returned by the transform function must support the Add and Divide(Int32) operators</remarks>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Max``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Computes the maximum (using a custom comparer) of a sequence of values.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Max``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Computes the maximum (using a custom comparer) of the sequence of values that are
            obtained by invoking a transform function on each element of the input sequence.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Min``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Computes the minimum (using a custom comparer) of a sequence of values.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.EnumerableExt.Min``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Computes the minimum (using a custom comparer) of the sequence of values that are
            obtained by invoking a transform function on each element of the input sequence.
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.Endianness">
            <summary>
            Endianness of a converter
            </summary>
        </member>
        <member name="F:MiscUtil.Conversion.Endianness.LittleEndian">
            <summary>
            Little endian - least significant byte first
            </summary>
        </member>
        <member name="F:MiscUtil.Conversion.Endianness.BigEndian">
            <summary>
            Big endian - most significant byte first
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.VcdiffDecoder">
            <summary>
            Decoder for VCDIFF (RFC 3284) streams.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.VcdiffDecoder.original">
            <summary>
            Reader containing original data, if any. May be null.
            If non-null, will be readable and seekable.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.VcdiffDecoder.delta">
            <summary>
            Stream containing delta data. Will be readable.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.VcdiffDecoder.output">
            <summary>
            Stream containing target data. Will be readable,
            writable and seekable.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.VcdiffDecoder.codeTable">
            <summary>
            Code table to use for decoding.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.VcdiffDecoder.cache">
            <summary>
            Address cache to use when decoding; must be reset before decoding each window.
            Default to the default size.
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.#ctor(System.IO.Stream,System.IO.Stream,System.IO.Stream)">
            <summary>
            Sole constructor; private to prevent instantiation from
            outside the class.
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.Decode(System.IO.Stream,System.IO.Stream,System.IO.Stream)">
            <summary>
            Decodes an original stream and a delta stream, writing to a target stream.
            The original stream may be null, so long as the delta stream never
            refers to it. The original and delta streams must be readable, and the
            original stream (if any) and the target stream must be seekable. 
            The target stream must be writable and readable. The original and target
            streams are rewound to their starts before any data is read; the relevant data
            must occur at the beginning of the original stream, and any data already present
            in the target stream may be overwritten. The delta data must begin
            wherever the delta stream is currently positioned. The delta stream must end
            after the last window. The streams are not disposed by this method.
            </summary>
            <param name="original">Stream containing delta. May be null.</param>
            <param name="delta">Stream containing delta data.</param>
            <param name="output">Stream to write resulting data to.</param>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.Decode">
            <summary>
            Top-level decoding method. When this method exits, all decoding has been performed.
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.ReadHeader">
            <summary>
            Read the header, including any custom code table. The delta stream is left
            positioned at the start of the first window.
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.ReadCodeTable">
            <summary>
            Reads the custom code table, if there is one
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.VcdiffDecoder.DecodeWindow">
            <summary>
            Reads and decodes a window, returning whether or not there was
            any more data to read.
            </summary>
            <returns>
            Whether or not the delta stream had reached the end of its data.
            </returns>
        </member>
        <member name="T:MiscUtil.Linq.DataProducer`1">
            <summary>
            Very simple implementation of IDataProducer.
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:MiscUtil.Linq.DataProducer`1.Produce(`0)">
            <summary>
            Signals a single item of data.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.DataProducer`1.ProduceAndEnd(`0[])">
            <summary>
            Signals multiple items of data, one at a time, then ends.
            Note that this method only exists to support the params modifier.
            In every other way it's equivalent to the ProduceAndEnd(IEnumerable{T}).
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.DataProducer`1.ProduceAndEnd(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Signals multiple items of data, one at a time, then ends.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.DataProducer`1.PumpProduceAndEnd``1(System.Collections.Generic.IEnumerable{`0},MiscUtil.Linq.IDataProducer{``0})">
            <summary>
            Pumps the specified items into this data producer, yielding results
            as they are received. Before an item is pumped, an internal queue is
            created. Pumping an item may yield results at the other end of the pipeline
            - any such results are buffered in the queue. When the pumping of a particular
            item has finished, all results in the queue are yielded. This means that
            naturally streaming operations (projection and filtering) require only a single item
            buffer. This producer "ends" when all the items have been produced. If the result
            pipeline ends before all items have been pumped, the buffered results are yielded
            but no more items are pumped.
            </summary>
            <typeparam name="TResult">Type of element in the result pipeline</typeparam>
            <param name="items">Items to insert into the pipeline</param>
            <param name="pipeline">The pipeline to subscribe to for items to yield</param>
            <returns>A sequence of yielded items.</returns>
        </member>
        <member name="M:MiscUtil.Linq.DataProducer`1.End">
            <summary>
            Signal the end of data. This can only be called once, and
            afterwards the Produce method must not be called.
            </summary>
        </member>
        <member name="E:MiscUtil.Linq.DataProducer`1.DataProduced">
            <summary>
            Event which is raised when an item of data is produced.
            This will not be raised after EndOfData has been raised.
            The parameter for the event is the 
            </summary>
            <seealso cref="E:MiscUtil.Linq.IDataProducer`1.DataProduced"/>
        </member>
        <member name="E:MiscUtil.Linq.DataProducer`1.EndOfData">
            <summary>
            Event which is raised when the sequence has finished being
            produced. This will be raised exactly once, and after all
            DataProduced events (if any) have been raised.
            </summary>
            <seealso cref="E:MiscUtil.Linq.IDataProducer`1.EndOfData"/>
        </member>
        <member name="T:MiscUtil.GenericMath">
            <summary>
            Generic math equivalents of System.Math.
            (Calling this just Math makes far too much mess.)
            </summary>
        </member>
        <member name="M:MiscUtil.GenericMath.Abs``1(``0)">
            <summary>
            Returns the absolute value of a specified number.
            </summary>
            <typeparam name="T">Type to calculate with</typeparam>
            <param name="input">Input to return the absolute value of.</param>
            <returns>The input value if it is greater than or equal to the default value of T,
            or the negated input value otherwise</returns>
        </member>
        <member name="M:MiscUtil.GenericMath.WithinDelta``1(``0,``0,``0)">
            <summary>
            Returns whether or not two inputs are "close" to each other with respect to a given delta.
            </summary>
            <remarks>
            This implementation currently does no overflow checking - if (input1-input2) overflows, it
            could yield the wrong result.
            </remarks>
            <typeparam name="T">Type to calculate with</typeparam>
            <param name="input1">First input value</param>
            <param name="input2">Second input value</param>
            <param name="delta">Permitted range (exclusive)</param>
            <returns>True if Abs(input1-input2) is less than or equal to delta; false otherwise.</returns>
        </member>
        <member name="T:MiscUtil.Threading.SyncLock">
            <summary>
            Class used for locking, as an alternative to just locking on normal monitors.
            Allows for timeouts when locking, and each Lock method returns a token which
            must then be disposed of to release the internal monitor (i.e. to unlock).
            All properties and methods of this class are thread-safe.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.SyncLock.staticLock">
            <summary>
            Lock for static mutable properties.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.SyncLock.defaultDefaultTimeout">
            <summary>
            The default timeout for new instances of this class
            where the default timeout isn't otherwise specified.
            Defaults to Timeout.Infinite.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.#ctor">
            <summary>
            Creates a new lock with no name, and the default timeout specified by DefaultDefaultTimeout.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.#ctor(System.String)">
            <summary>
            Creates a new lock with the specified name, and the default timeout specified by
            DefaultDefaultTimeout.
            </summary>
            <param name="name">The name of the new lock</param>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.#ctor(System.Int32)">
            <summary>
            Creates a new lock with no name, and the specified default timeout
            </summary>
            <param name="defaultTimeout">Default timeout, in milliseconds</param>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.#ctor(System.String,System.Int32)">
            <summary>
            Creates a new lock with the specified name, and an
            infinite default timeout.
            </summary>
            <param name="name">The name of the new lock</param>
            <param name="defaultTimeout">
            Default timeout, in milliseconds. Use Timeout.Infinite
            for an infinite timeout, or a non-negative number otherwise.
            </param>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.Lock">
            <summary>
            Locks the monitor, with the default timeout.
            </summary>
            <returns>A lock token which should be disposed to release the lock</returns>
            <exception cref="T:MiscUtil.Threading.LockTimeoutException">The operation times out.</exception>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.Lock(System.TimeSpan)">
            <summary>
            Locks the monitor, with the specified timeout.
            </summary>
            <param name="timeout">The timeout duration. When converted to milliseconds, 
            must be Timeout.Infinite, or non-negative.</param>
            <returns>A lock token which should be disposed to release the lock</returns>
            <exception cref="T:MiscUtil.Threading.LockTimeoutException">The operation times out.</exception>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.Lock(System.Int32)">
            <summary>
            Locks the monitor, with the specified timeout. Derived classes may override
            this method to change the behaviour; the other calls to Lock all result in
            a call to this method. This implementation checks the validity of the timeout,
            calls Monitor.TryEnter (throwing an exception if appropriate) and returns a
            new LockToken.
            </summary>
            <param name="timeout">The timeout, in milliseconds. Must be Timeout.Infinite,
            or non-negative.</param>
            <returns>A lock token which should be disposed to release the lock</returns>
            <exception cref="T:MiscUtil.Threading.LockTimeoutException">The operation times out.</exception>
        </member>
        <member name="M:MiscUtil.Threading.SyncLock.Unlock">
            <summary>
            Unlocks the monitor. This method may be overridden in derived classes
            to change the behaviour. This implementation simply calls Monitor.Exit.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.SyncLock.DefaultTimeout">
            <summary>
            The default timeout for the 
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.SyncLock.Name">
            <summary>
            The name of this lock.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.SyncLock.Monitor">
            <summary>
            The internal monitor used for locking. While this
            is owned by the thread, it can be used for waiting
            and pulsing in the usual way. Note that manually entering/exiting
            this monitor could result in the lock malfunctioning.
            </summary>
        </member>
        <member name="T:MiscUtil.IBufferManager">
            <summary>
            Interface for classes which manage instances of
            IBuffer.
            </summary>
        </member>
        <member name="M:MiscUtil.IBufferManager.GetBuffer(System.Int32)">
            <summary>
            Returns a buffer of the given size or greater.
            </summary>
            <param name="minimumSize">The minimum size of buffer to return</param>
            <exception cref="T:MiscUtil.BufferAcquisitionException">This manager is unable
            to return a buffer of the appropriate size</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">minimumSize is less than
            or equal to 0</exception>
        </member>
        <member name="T:MiscUtil.Extensions.ObjectExt">
            <summary>
            Extension methods on all reference types. 
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.ObjectExt.ThrowIfNull``1(``0,System.String)">
            <summary>
            Throws an ArgumentNullException if the given data item is null.
            </summary>
            <param name="data">The item to check for nullity.</param>
            <param name="name">The name to use when throwing an exception, if necessary</param>
        </member>
        <member name="M:MiscUtil.Extensions.ObjectExt.ThrowIfNull``1(``0)">
            <summary>
            Throws an ArgumentNullException if the given data item is null.
            No parameter name is specified.
            </summary>
            <param name="data">The item to check for nullity.</param>
        </member>
        <member name="T:MiscUtil.EventArgs`1">
            <summary>
            Generic event argument taking a single value
            </summary>
        </member>
        <member name="M:MiscUtil.EventArgs`1.#ctor(`0)">
            <summary>
            Creates a new EventArgs&lt;T&gt; with the specified value.
            </summary>
            <param name="value">The Value of the EventArgs&lt;T&gt; instance.</param>
        </member>
        <member name="P:MiscUtil.EventArgs`1.Value">
            <summary>
            The typed value of the EventArgs&lt;T&gt;
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.DoubleConverter">
            <summary>
            A class to allow the conversion of doubles to string representations of
            their exact decimal values. The implementation aims for readability over
            efficiency.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ToExactString(System.Double)">
            <summary>
            Converts the given double to a string representation of its
            exact decimal value.
            </summary>
            <param name="d">The double to convert.</param>
            <returns>A string representation of the double's exact decimal value.</returns>
        </member>
        <member name="T:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal">
            <summary>
            Private class used for manipulating sequences of decimal digits.
            </summary>
        </member>
        <member name="F:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.digits">
            <summary>Digits in the decimal expansion, one byte per digit</summary>
        </member>
        <member name="F:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.decimalPoint">
            <summary> 
            How many digits are *after* the decimal point
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.#ctor(System.Int64)">
            <summary> 
            Constructs an arbitrary decimal expansion from the given long.
            The long must not be negative.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.MultiplyBy(System.Int32)">
            <summary>
            Multiplies the current expansion by the given amount, which should
            only be 2 or 5.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.Shift(System.Int32)">
            <summary>
            Shifts the decimal point; a negative value makes
            the decimal expansion bigger (as fewer digits come after the
            decimal place) and a positive value makes the decimal
            expansion smaller.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.Normalize">
            <summary>
            Removes leading/trailing zeroes from the expansion.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.DoubleConverter.ArbitraryDecimal.ToString">
            <summary>
            Converts the value to a proper decimal string representation.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.Range`1">
            <summary>
            Represents a range of values. An IComparer{T} is used to compare specific
            values with a start and end point. A range may be include or exclude each end
            individually.
            
            A range which is half-open but has the same start and end point is deemed to be empty,
            e.g. [3,3) doesn't include 3. To create a range with a single value, use an inclusive
            range, e.g. [3,3].
            
            Ranges are always immutable - calls such as IncludeEnd() and ExcludeEnd() return a new
            range without modifying this one.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.#ctor(`0,`0)">
            <summary>
            Constructs a new inclusive range using the default comparer
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.#ctor(`0,`0,System.Collections.Generic.IComparer{`0})">
            <summary>
            Constructs a new range including both ends using the specified comparer
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.#ctor(`0,`0,System.Collections.Generic.IComparer{`0},System.Boolean,System.Boolean)">
            <summary>
            Constructs a new range, including or excluding each end as specified,
            with the given comparer.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.ExcludeEnd">
            <summary>
            Returns a range with the same boundaries as this, but excluding the end point.
            When called on a range already excluding the end point, the original range is returned.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.ExcludeStart">
            <summary>
            Returns a range with the same boundaries as this, but excluding the start point.
            When called on a range already excluding the start point, the original range is returned.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.IncludeEnd">
            <summary>
            Returns a range with the same boundaries as this, but including the end point.
            When called on a range already including the end point, the original range is returned.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.IncludeStart">
            <summary>
            Returns a range with the same boundaries as this, but including the start point.
            When called on a range already including the start point, the original range is returned.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.Contains(`0)">
            <summary>
            Returns whether or not the range contains the given value
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.FromStart(System.Func{`0,`0})">
            <summary>
            Returns an iterator which begins at the start of this range,
            applying the given step delegate on each iteration until the 
            end is reached or passed. The start and end points are included
            or excluded according to this range.
            </summary>
            <param name="step">Delegate to apply to the "current value" on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.FromEnd(System.Func{`0,`0})">
            <summary>
            Returns an iterator which begins at the end of this range,
            applying the given step delegate on each iteration until the 
            start is reached or passed. The start and end points are included
            or excluded according to this range.
            </summary>
            <param name="step">Delegate to apply to the "current value" on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.UpBy(`0)">
            <summary>
            Returns an iterator which begins at the start of this range,
            adding the given step amount to the current value each iteration until the 
            end is reached or passed. The start and end points are included
            or excluded according to this range. This method does not check for
            the availability of an addition operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">Amount to add on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.DownBy(`0)">
            <summary>
            Returns an iterator which begins at the end of this range,
            subtracting the given step amount to the current value each iteration until the 
            start is reached or passed. The start and end points are included
            or excluded according to this range. This method does not check for
            the availability of a subtraction operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">Amount to subtract on each iteration. Note that
            this is subtracted, so in a range [0,10] you would pass +2 as this parameter
            to obtain the sequence (10, 8, 6, 4, 2, 0).
            </param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.UpBy``1(``0)">
            <summary>
            Returns an iterator which begins at the start of this range,
            adding the given step amount to the current value each iteration until the 
            end is reached or passed. The start and end points are included
            or excluded according to this range. This method does not check for
            the availability of an addition operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">Amount to add on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.DownBy``1(``0)">
            <summary>
            Returns an iterator which begins at the end of this range,
            subtracting the given step amount to the current value each iteration until the 
            start is reached or passed. The start and end points are included
            or excluded according to this range. This method does not check for
            the availability of a subtraction operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">Amount to subtract on each iteration. Note that
            this is subtracted, so in a range [0,10] you would pass +2 as this parameter
            to obtain the sequence (10, 8, 6, 4, 2, 0).
            </param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.Step(System.Func{`0,`0})">
            <summary>
            Returns an iterator which steps through the range, applying the specified
            step delegate on each iteration. The method determines whether to begin 
            at the start or end of the range based on whether the step delegate appears to go
            "up" or "down". The step delegate is applied to the start point. If the result is 
            more than the start point, the returned iterator begins at the start point; otherwise
            it begins at the end point.
            </summary>
            <param name="step">Delegate to apply to the "current value" on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.Step(`0)">
            <summary>
            Returns an iterator which steps through the range, adding the specified amount
            on each iteration. If the step amount is logically negative, the returned iterator
            begins at the start point; otherwise it begins at the end point.
            This method does not check for
            the availability of an addition operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">The amount to add on each iteration</param>
        </member>
        <member name="M:MiscUtil.Collections.Range`1.Step``1(``0)">
            <summary>
            Returns an iterator which steps through the range, adding the specified amount
            on each iteration. If the step amount is logically negative, the returned iterator
            begins at the end point; otherwise it begins at the start point. This method
            is equivalent to Step(T stepAmount), but allows an alternative type to be used.
            The most common example of this is likely to be stepping a range of DateTimes
            by a TimeSpan.
            This method does not check for
            the availability of a suitable addition operator at compile-time; if you use it
            on a range where there is no such operator, it will fail at execution time.
            </summary>
            <param name="stepAmount">The amount to add on each iteration</param>
        </member>
        <member name="P:MiscUtil.Collections.Range`1.Start">
            <summary>
            The start of the range.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.Range`1.End">
            <summary>
            The end of the range.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.Range`1.Comparer">
            <summary>
            Comparer to use for comparisons
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.Range`1.IncludesStart">
            <summary>
            Whether or not this range includes the start point
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.Range`1.IncludesEnd">
            <summary>
            Whether or not this range includes the end point
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.ProjectionEqualityComparer">
            <summary>
            Non-generic class to produce instances of the generic class,
            optionally using type inference.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer.Create``2(System.Func{``0,``1})">
            <summary>
            Creates an instance of ProjectionEqualityComparer using the specified projection.
            </summary>
            <typeparam name="TSource">Type parameter for the elements to be compared</typeparam>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer.Create``2(``0,System.Func{``0,``1})">
            <summary>
            Creates an instance of ProjectionEqualityComparer using the specified projection.
            The ignored parameter is solely present to aid type inference.
            </summary>
            <typeparam name="TSource">Type parameter for the elements to be compared</typeparam>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="ignored">Value is ignored - type may be used by type inference</param>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>
        </member>
        <member name="T:MiscUtil.Collections.ProjectionEqualityComparer`1">
            <summary>
            Class generic in the source only to produce instances of the 
            doubly generic class, optionally using type inference.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer`1.Create``1(System.Func{`0,``0})">
            <summary>
            Creates an instance of ProjectionEqualityComparer using the specified projection.
            </summary>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>        
        </member>
        <member name="T:MiscUtil.Collections.ProjectionEqualityComparer`2">
            <summary>
            Comparer which projects each element of the comparison to a key, and then compares
            those keys using the specified (or default) comparer for the key type.
            </summary>
            <typeparam name="TSource">Type of elements which this comparer will be asked to compare</typeparam>
            <typeparam name="TKey">Type of the key projected from the element</typeparam>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer`2.#ctor(System.Func{`0,`1})">
            <summary>
            Creates a new instance using the specified projection, which must not be null.
            The default comparer for the projected type is used.
            </summary>
            <param name="projection">Projection to use during comparisons</param>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer`2.#ctor(System.Func{`0,`1},System.Collections.Generic.IEqualityComparer{`1})">
            <summary>
            Creates a new instance using the specified projection, which must not be null.
            </summary>
            <param name="projection">Projection to use during comparisons</param>
            <param name="comparer">The comparer to use on the keys. May be null, in
            which case the default comparer will be used.</param>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer`2.Equals(`0,`0)">
            <summary>
            Compares the two specified values for equality by applying the projection
            to each value and then using the equality comparer on the resulting keys. Null
            references are never passed to the projection.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionEqualityComparer`2.GetHashCode(`0)">
            <summary>
            Produces a hash code for the given value by projecting it and
            then asking the equality comparer to find the hash code of
            the resulting key.
            </summary>
        </member>
        <member name="T:MiscUtil.CachingBufferManager">
            <summary>
            An implementation of IBufferManager which keeps a cache of
            buffers. The precise behaviour is controlled by the nested Options
            class.
            
            This class is safe to use from multiple threads, but buffers
            returned are not inherently thread safe (although they have no
            thread affinity).
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.options">
            <summary>
            Options configurating this manager.
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.bufferBands">
            <summary>
            List of bands. Each entry is an array
            of size MaxBuffersPerSizeBand. Each entry of that array is either
            null or a buffer, which may or may not be in use. The first entry
            in the list consists of buffers of size MinBufferSize, then
            MinBufferSize*ScalingFactor etc.
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.padlock">
            <summary>
            Lock for member access. 5 seconds should be more than adequate
            as a timeout.
            </summary>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.#ctor">
            <summary>
            Creates a caching buffer manager configured with the default options
            (as per a freshly created instance of Options).
            </summary>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.#ctor(MiscUtil.CachingBufferManager.Options)">
            <summary>
            Creates a caching buffer manager configured with the specified
            options. Note that the options are cloned - any changes to the
            options passed in after construction will have no effect on the
            manager.
            </summary>
            <param name="options">The configuration options for this manager.</param>
            <exception cref="T:System.ArgumentException">The configuration is invalid</exception>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.GetBuffer(System.Int32)">
            <summary>
            Returns a buffer of the given size or greater.
            </summary>
            <exception cref="T:MiscUtil.BufferAcquisitionException">If the buffer could
            not be taken from a pool, and the ActionOnBufferUnavailable
            is set to ThrowException, or if the specified size is greater
            than the maximum buffer size.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">If minimumSize is less than 0.</exception>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.CalculateNextSizeBand(System.Int32)">
            <summary>
            Works out the size of the next band up from the current size.
            This is based on the scaling factor in the options, the maximum buffer
            size, and the requirement that the returned size should always be
            greater than the original one. (This is achieved using Ceiling -
            the worst case is when size is 1 and the scaling factor is 1.25,
            whereupon Ceiling will return 2.)
            </summary>
            <param name="size"></param>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.FindAvailableBuffer(System.Int32,System.Int32)">
            <summary>
            Finds an available buffer from the list, creating a new buffer
            where appropriate.
            </summary>
            <param name="listIndex">Index into the list of buffer slots</param>
            <param name="size">Size of buffer to create if necessary</param>
            <returns>An available buffer, or null if none are available in the given band.</returns>
        </member>
        <member name="T:MiscUtil.CachingBufferManager.Options">
            <summary>
            Provides options for CachingBufferManager.
            </summary>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.Options.Clone">
            <summary>
            Strongly typed Clone implementation.
            </summary>
            <returns>A clone of these options</returns>
        </member>
        <member name="M:MiscUtil.CachingBufferManager.Options.System#ICloneable#Clone">
            <summary>
            Weakly typed Clone implementation.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.MaxBuffersPerSizeBand">
            <summary>
            The maximum number of buffers to keep for each
            size band. When a buffer is requested from one size band,
            if none are available and this many buffers have already
            been allocated, a buffer from the next size band is
            returned (using the same algorithm). Defaults to 16;
            must not be less than 1.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.MinBufferSize">
            <summary>
            The minimum buffer size to use, in bytes. If a buffer less than this size is
            requested, this is the size that will actually be used. Must be at least 1.
            On construction of the CachingBufferManager, this must not be greater than
            MaxBufferSize. Defaults to 1024.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.ClearAfterUse">
            <summary>
            Whether buffers are cleared (i.e. all bytes set to 0) after they
            are disposed. Defaults to true. For situations where buffers do not
            contain any sensitive information, and all clients know to only use
            data they have specifically put into the buffer (e.g. when copying
            streams), this may be set to false for efficiency.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.ScalingFactor">
            <summary>
            The scaling factor for sizes of buffers. The smallest buffer is of size
            MinBufferSize, then the next smallest is MinBufferSize*ScalingFactor, and
            so forth. The default is 2.0, so with the default buffer size of 1K, buffers
            will be 1K, 2K, 4K, 8K etc. The value must be greater than or equal to 1.25.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.MaxBufferSize">
            <summary>
            The maximum size of buffer to return, or 0 for no maximum.
            This is primarily used with an ActionOnBufferUnavailable of UseBigger,
            which could potentially create bigger and bigger buffers. If a buffer
            of a size greater than this is requested, a BufferAcquisitionException will
            be thrown. Defaults to Int32.MaxValue. The value must be greater than 0.
            On construction of the CachingBufferManager, this must not be less than
            MinBufferSize.
            </summary>
        </member>
        <member name="P:MiscUtil.CachingBufferManager.Options.ActionOnBufferUnavailable">
            <summary>
            Determines the action to take when a buffer of the most appropriate size
            is unavailable. Defaults to ReturnUncached.
            </summary>
        </member>
        <member name="T:MiscUtil.CachingBufferManager.Options.BufferUnavailableAction">
            <summary>
            Enumeration of options available when a buffer of the most appropriate size
            is unavailable.
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.Options.BufferUnavailableAction.UseBigger">
            <summary>
            A buffer of the next size band up is returned, or the size band above that,
            etc, until the maximum size is reached, at which point this fails over to
            ReturnUncached.
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.Options.BufferUnavailableAction.ReturnUncached">
            <summary>
            A buffer of exactly the right size is returned, but one which when disposed
            does not return the buffer to a cache.
            </summary>
        </member>
        <member name="F:MiscUtil.CachingBufferManager.Options.BufferUnavailableAction.ThrowException">
            <summary>
            A BufferAcquisitionException is thrown.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.RangeIterator`1">
            <summary>
            Iterates over a range. Despite its name, this implements IEnumerable{T} rather than
            IEnumerator{T} - it just sounds better, frankly.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RangeIterator`1.#ctor(MiscUtil.Collections.Range{`0},System.Func{`0,`0})">
            <summary>
            Creates an ascending iterator over the given range with the given step function
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RangeIterator`1.#ctor(MiscUtil.Collections.Range{`0},System.Func{`0,`0},System.Boolean)">
            <summary>
            Creates an iterator over the given range with the given step function,
            with the specified direction.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RangeIterator`1.GetEnumerator">
            <summary>
            Returns an IEnumerator{T} running over the range.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.RangeIterator`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Returns an IEnumerator running over the range.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RangeIterator`1.Range">
            <summary>
            Returns the range this object iterates over
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RangeIterator`1.Step">
            <summary>
            Returns the step function used for this range
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.RangeIterator`1.Ascending">
            <summary>
            Returns whether or not this iterator works up from the start point (ascending)
            or down from the end point (descending)
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.Extensions.DictionaryExt">
            <summary>
            Extensions to IDictionary
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.DictionaryExt.GetOrCreate``2(System.Collections.Generic.IDictionary{``0,``1},``0)">
            <summary>
            Returns the value associated with the specified key if there
            already is one, or inserts a new value for the specified key and
            returns that.
            </summary>
            <typeparam name="TKey">Type of key</typeparam>
            <typeparam name="TValue">Type of value, which must either have
            a public parameterless constructor or be a value type</typeparam>
            <param name="dictionary">Dictionary to access</param>
            <param name="key">Key to lookup</param>
            <returns>Existing value in the dictionary, or new one inserted</returns>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.DictionaryExt.GetOrCreate``2(System.Collections.Generic.IDictionary{``0,``1},``0,System.Func{``1})">
            <summary>
            Returns the value associated with the specified key if there already
            is one, or calls the specified delegate to create a new value which is
            stored and returned.
            </summary>
            <typeparam name="TKey">Type of key</typeparam>
            <typeparam name="TValue">Type of value</typeparam>
            <param name="dictionary">Dictionary to access</param>
            <param name="key">Key to lookup</param>
            <param name="valueProvider">Delegate to provide new value if required</param>
            <returns>Existing value in the dictionary, or new one inserted</returns>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.DictionaryExt.GetOrCreate``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1)">
            <summary>
            Returns the value associated with the specified key if there
            already is one, or inserts the specified value and returns it.
            </summary>
            <typeparam name="TKey">Type of key</typeparam>
            <typeparam name="TValue">Type of value</typeparam>
            <param name="dictionary">Dictionary to access</param>
            <param name="key">Key to lookup</param>
            <param name="missingValue">Value to use when key is missing</param>
            <returns>Existing value in the dictionary, or new one inserted</returns>
        </member>
        <member name="T:MiscUtil.IO.EndianBinaryWriter">
            <summary>
            Equivalent of System.IO.BinaryWriter, but with either endianness, depending on
            the EndianBitConverter it is constructed with.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryWriter.disposed">
            <summary>
            Whether or not this writer has been disposed yet.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryWriter.buffer">
            <summary>
            Buffer used for temporary storage during conversion from primitives
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryWriter.charBuffer">
            <summary>
            Buffer used for Write(char)
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.#ctor(MiscUtil.Conversion.EndianBitConverter,System.IO.Stream)">
            <summary>
            Constructs a new binary writer with the given bit converter, writing
            to the given stream, using UTF-8 encoding.
            </summary>
            <param name="bitConverter">Converter to use when writing data</param>
            <param name="stream">Stream to write data to</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.#ctor(MiscUtil.Conversion.EndianBitConverter,System.IO.Stream,System.Text.Encoding)">
            <summary>
            Constructs a new binary writer with the given bit converter, writing
            to the given stream, using the given encoding.
            </summary>
            <param name="bitConverter">Converter to use when writing data</param>
            <param name="stream">Stream to write data to</param>
            <param name="encoding">Encoding to use when writing character data</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Close">
            <summary>
            Closes the writer, including the underlying stream.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Flush">
            <summary>
            Flushes the underlying stream.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Seek(System.Int32,System.IO.SeekOrigin)">
            <summary>
            Seeks within the stream.
            </summary>
            <param name="offset">Offset to seek to.</param>
            <param name="origin">Origin of seek operation.</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Boolean)">
            <summary>
            Writes a boolean value to the stream. 1 byte is written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Int16)">
            <summary>
            Writes a 16-bit signed integer to the stream, using the bit converter
            for this writer. 2 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Int32)">
            <summary>
            Writes a 32-bit signed integer to the stream, using the bit converter
            for this writer. 4 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Int64)">
            <summary>
            Writes a 64-bit signed integer to the stream, using the bit converter
            for this writer. 8 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.UInt16)">
            <summary>
            Writes a 16-bit unsigned integer to the stream, using the bit converter
            for this writer. 2 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.UInt32)">
            <summary>
            Writes a 32-bit unsigned integer to the stream, using the bit converter
            for this writer. 4 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.UInt64)">
            <summary>
            Writes a 64-bit unsigned integer to the stream, using the bit converter
            for this writer. 8 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Single)">
            <summary>
            Writes a single-precision floating-point value to the stream, using the bit converter
            for this writer. 4 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Double)">
            <summary>
            Writes a double-precision floating-point value to the stream, using the bit converter
            for this writer. 8 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Decimal)">
            <summary>
            Writes a decimal value to the stream, using the bit converter for this writer.
            16 bytes are written.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Byte)">
            <summary>
            Writes a signed byte to the stream.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.SByte)">
            <summary>
            Writes an unsigned byte to the stream.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Byte[])">
            <summary>
            Writes an array of bytes to the stream.
            </summary>
            <param name="value">The values to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Writes a portion of an array of bytes to the stream.
            </summary>
            <param name="value">An array containing the bytes to write</param>
            <param name="offset">The index of the first byte to write within the array</param>
            <param name="count">The number of bytes to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Char)">
            <summary>
            Writes a single character to the stream, using the encoding for this writer.
            </summary>
            <param name="value">The value to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.Char[])">
            <summary>
            Writes an array of characters to the stream, using the encoding for this writer.
            </summary>
            <param name="value">An array containing the characters to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write(System.String)">
            <summary>
            Writes a string to the stream, using the encoding for this writer.
            </summary>
            <param name="value">The value to write. Must not be null.</param>
            <exception cref="T:System.ArgumentNullException">value is null</exception>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Write7BitEncodedInt(System.Int32)">
            <summary>
            Writes a 7-bit encoded integer from the stream. This is stored with the least significant
            information first, with 7 bits of information per byte of value, and the top
            bit as a continuation flag.
            </summary>
            <param name="value">The 7-bit encoded integer to write to the stream</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.CheckDisposed">
            <summary>
            Checks whether or not the writer has been disposed, throwing an exception if so.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.WriteInternal(System.Byte[],System.Int32)">
            <summary>
            Writes the specified number of bytes from the start of the given byte array,
            after checking whether or not the writer has been disposed.
            </summary>
            <param name="bytes">The array of bytes to write from</param>
            <param name="length">The number of bytes to write</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryWriter.Dispose">
            <summary>
            Disposes of the underlying stream.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryWriter.BitConverter">
            <summary>
            The bit converter used to write values to the stream
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryWriter.Encoding">
            <summary>
            The encoding used to write strings
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryWriter.BaseStream">
            <summary>
            Gets the underlying stream of the EndianBinaryWriter.
            </summary>
        </member>
        <member name="T:MiscUtil.IO.EndianBinaryReader">
            <summary>
            Equivalent of System.IO.BinaryReader, but with either endianness, depending on
            the EndianBitConverter it is constructed with. No data is buffered in the
            reader; the client may seek within the stream at will.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryReader.disposed">
            <summary>
            Whether or not this reader has been disposed yet.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryReader.decoder">
            <summary>
            Decoder to use for string conversions.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryReader.buffer">
            <summary>
            Buffer used for temporary storage before conversion into primitives
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryReader.charBuffer">
            <summary>
            Buffer used for temporary storage when reading a single character
            </summary>
        </member>
        <member name="F:MiscUtil.IO.EndianBinaryReader.minBytesPerChar">
            <summary>
            Minimum number of bytes used to encode a character
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.#ctor(MiscUtil.Conversion.EndianBitConverter,System.IO.Stream)">
            <summary>
            Equivalent of System.IO.BinaryWriter, but with either endianness, depending on
            the EndianBitConverter it is constructed with.
            </summary>
            <param name="bitConverter">Converter to use when reading data</param>
            <param name="stream">Stream to read data from</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.#ctor(MiscUtil.Conversion.EndianBitConverter,System.IO.Stream,System.Text.Encoding)">
            <summary>
            Constructs a new binary reader with the given bit converter, reading
            to the given stream, using the given encoding.
            </summary>
            <param name="bitConverter">Converter to use when reading data</param>
            <param name="stream">Stream to read data from</param>
            <param name="encoding">Encoding to use when reading character data</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Close">
            <summary>
            Closes the reader, including the underlying stream..
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Seek(System.Int32,System.IO.SeekOrigin)">
            <summary>
            Seeks within the stream.
            </summary>
            <param name="offset">Offset to seek to.</param>
            <param name="origin">Origin of seek operation.</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadByte">
            <summary>
            Reads a single byte from the stream.
            </summary>
            <returns>The byte read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadSByte">
            <summary>
            Reads a single signed byte from the stream.
            </summary>
            <returns>The byte read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadBoolean">
            <summary>
            Reads a boolean from the stream. 1 byte is read.
            </summary>
            <returns>The boolean read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadInt16">
            <summary>
            Reads a 16-bit signed integer from the stream, using the bit converter
            for this reader. 2 bytes are read.
            </summary>
            <returns>The 16-bit integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadInt32">
            <summary>
            Reads a 32-bit signed integer from the stream, using the bit converter
            for this reader. 4 bytes are read.
            </summary>
            <returns>The 32-bit integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadInt64">
            <summary>
            Reads a 64-bit signed integer from the stream, using the bit converter
            for this reader. 8 bytes are read.
            </summary>
            <returns>The 64-bit integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadUInt16">
            <summary>
            Reads a 16-bit unsigned integer from the stream, using the bit converter
            for this reader. 2 bytes are read.
            </summary>
            <returns>The 16-bit unsigned integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadUInt32">
            <summary>
            Reads a 32-bit unsigned integer from the stream, using the bit converter
            for this reader. 4 bytes are read.
            </summary>
            <returns>The 32-bit unsigned integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadUInt64">
            <summary>
            Reads a 64-bit unsigned integer from the stream, using the bit converter
            for this reader. 8 bytes are read.
            </summary>
            <returns>The 64-bit unsigned integer read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadSingle">
            <summary>
            Reads a single-precision floating-point value from the stream, using the bit converter
            for this reader. 4 bytes are read.
            </summary>
            <returns>The floating point value read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadDouble">
            <summary>
            Reads a double-precision floating-point value from the stream, using the bit converter
            for this reader. 8 bytes are read.
            </summary>
            <returns>The floating point value read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadDecimal">
            <summary>
            Reads a decimal value from the stream, using the bit converter
            for this reader. 16 bytes are read.
            </summary>
            <returns>The decimal value read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Read">
            <summary>
            Reads a single character from the stream, using the character encoding for
            this reader. If no characters have been fully read by the time the stream ends,
            -1 is returned.
            </summary>
            <returns>The character read, or -1 for end of stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Read(System.Char[],System.Int32,System.Int32)">
            <summary>
            Reads the specified number of characters into the given buffer, starting at
            the given index.
            </summary>
            <param name="data">The buffer to copy data into</param>
            <param name="index">The first index to copy data into</param>
            <param name="count">The number of characters to read</param>
            <returns>The number of characters actually read. This will only be less than
            the requested number of characters if the end of the stream is reached.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads the specified number of bytes into the given buffer, starting at
            the given index.
            </summary>
            <param name="buffer">The buffer to copy data into</param>
            <param name="index">The first index to copy data into</param>
            <param name="count">The number of bytes to read</param>
            <returns>The number of bytes actually read. This will only be less than
            the requested number of bytes if the end of the stream is reached.
            </returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadBytes(System.Int32)">
            <summary>
            Reads the specified number of bytes, returning them in a new byte array.
            If not enough bytes are available before the end of the stream, this
            method will return what is available.
            </summary>
            <param name="count">The number of bytes to read</param>
            <returns>The bytes read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadBytesOrThrow(System.Int32)">
            <summary>
            Reads the specified number of bytes, returning them in a new byte array.
            If not enough bytes are available before the end of the stream, this
            method will throw an IOException.
            </summary>
            <param name="count">The number of bytes to read</param>
            <returns>The bytes read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Read7BitEncodedInt">
            <summary>
            Reads a 7-bit encoded integer from the stream. This is stored with the least significant
            information first, with 7 bits of information per byte of value, and the top
            bit as a continuation flag. This method is not affected by the endianness
            of the bit converter.
            </summary>
            <returns>The 7-bit encoded integer read from the stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadBigEndian7BitEncodedInt">
            <summary>
            Reads a 7-bit encoded integer from the stream. This is stored with the most significant
            information first, with 7 bits of information per byte of value, and the top
            bit as a continuation flag. This method is not affected by the endianness
            of the bit converter.
            </summary>
            <returns>The 7-bit encoded integer read from the stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadString">
            <summary>
            Reads a length-prefixed string from the stream, using the encoding for this reader.
            A 7-bit encoded integer is first read, which specifies the number of bytes 
            to read from the stream. These bytes are then converted into a string with
            the encoding for this reader.
            </summary>
            <returns>The string read from the stream.</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.CheckDisposed">
            <summary>
            Checks whether or not the reader has been disposed, throwing an exception if so.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.ReadInternal(System.Byte[],System.Int32)">
            <summary>
            Reads the given number of bytes from the stream, throwing an exception
            if they can't all be read.
            </summary>
            <param name="data">Buffer to read into</param>
            <param name="size">Number of bytes to read</param>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.TryReadInternal(System.Byte[],System.Int32)">
            <summary>
            Reads the given number of bytes from the stream if possible, returning
            the number of bytes actually read, which may be less than requested if
            (and only if) the end of the stream is reached.
            </summary>
            <param name="data">Buffer to read into</param>
            <param name="size">Number of bytes to read</param>
            <returns>Number of bytes actually read</returns>
        </member>
        <member name="M:MiscUtil.IO.EndianBinaryReader.Dispose">
            <summary>
            Disposes of the underlying stream.
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryReader.BitConverter">
            <summary>
            The bit converter used to read values from the stream
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryReader.Encoding">
            <summary>
            The encoding used to read strings
            </summary>
        </member>
        <member name="P:MiscUtil.IO.EndianBinaryReader.BaseStream">
            <summary>
            Gets the underlying stream of the EndianBinaryReader.
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.InstructionType">
            <summary>
            Enumeration of the different instruction types.
            </summary>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.CodeTable">
            <summary>
            Table used to encode/decode instructions.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.CodeTable.Default">
            <summary>
            Default code table specified in RFC 3284.
            </summary>
        </member>
        <member name="F:MiscUtil.Compression.Vcdiff.CodeTable.entries">
            <summary>
            Array of entries in the code table
            </summary>
        </member>
        <member name="M:MiscUtil.Compression.Vcdiff.CodeTable.BuildDefaultCodeTable">
            <summary>
            Builds the default code table specified in RFC 3284
            </summary>
            <returns>
            The default code table.
            </returns>
        </member>
        <member name="P:MiscUtil.Compression.Vcdiff.CodeTable.Item(System.Int32,System.Int32)">
            <summary>
            
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.Extensions.ComparerExt">
            <summary>
            Extensions to IComparer
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.ComparerExt.Reverse``1(System.Collections.Generic.IComparer{``0})">
            <summary>
            Reverses the original comparer; if it was already a reverse comparer,
            the previous version was reversed (rather than reversing twice).
            In other words, for any comparer X, X==X.Reverse().Reverse().
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.ComparerExt.ThenBy``1(System.Collections.Generic.IComparer{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Combines a comparer with a second comparer to implement composite sort
            behaviour.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.ComparerExt.ThenBy``2(System.Collections.Generic.IComparer{``0},System.Func{``0,``1})">
            <summary>
            Combines a comparer with a projection to implement composite sort behaviour.
            </summary>
        </member>
        <member name="T:MiscUtil.PartialComparer">
            <summary>
            Class to provide partial comparisons, which can be useful when
            implementing full comparisons in other classes.
            </summary>
        </member>
        <member name="M:MiscUtil.PartialComparer.ReferenceCompare``1(``0,``0)">
            <summary>
            Provides comparisons for just the references, returning 0
            if the arguments are the same reference, -1 if just the first is null,
            and 1 if just the second is null. Otherwise, this method returns null.
            It can be used to make life easier for an initial comparison 
            before comparing individual components of an object.
            </summary>
            <typeparam name="T">The type of objects to compare</typeparam>
            <param name="first">The first object to compare</param>
            <param name="second">The second object to compare</param>
        </member>
        <member name="M:MiscUtil.PartialComparer.Compare``1(``0,``0)">
            <summary>
            Compares two instances of T using the default comparer for T,
            returning a non-null value in the case of inequality, or null 
            where the default comparer would return 0. This aids chained 
            comparisons (where if the first values are equal, you move 
            on to the next ones) if you use the null coalescing operator.
            </summary>
            <typeparam name="T">The type of objects to compare</typeparam>
            <param name="first">The first object to compare</param>
            <param name="second">The second object to compare</param>
        </member>
        <member name="M:MiscUtil.PartialComparer.Compare``1(System.Collections.Generic.IComparer{``0},``0,``0)">
            <summary>
            Compares two instances of T using the specified comparer for T,
            returning a non-null value in the case of inequality, or null 
            where the comparer would return 0. This aids chained 
            comparisons (where if the first values are equal, you move 
            on to the next ones) if you use the null coalescing operator.
            </summary>
            <typeparam name="T">The type of objects to compare</typeparam>
            <param name="comparer">The comparer to use</param>
            <param name="first">The first object to compare</param>
            <param name="second">The second object to compare</param>
        </member>
        <member name="M:MiscUtil.PartialComparer.Equals``1(``0,``0)">
            <summary>
            Compares two instances of T, returning true if they are definitely
            the same (i.e. the same references), false if exactly one reference is
            null, or null otherwise. This aids implementing equality operations.
            </summary>
            <typeparam name="T">The type of objects to compare</typeparam>
            <param name="first">The first object to compare</param>
            <param name="second">The second object to compare</param>
        </member>
        <member name="T:MiscUtil.IO.StreamUtil">
            <summary>
            Collection of utility methods which operate on streams.
            (With C# 3.0, these could well become extension methods on Stream.)
            </summary>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadFully(System.IO.Stream)">
            <summary>
            Reads the given stream up to the end, returning the data as a byte
            array.
            </summary>
            <param name="input">The stream to read from</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadFully(System.IO.Stream,System.Int32)">
            <summary>
            Reads the given stream up to the end, returning the data as a byte
            array, using the given buffer size.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="bufferSize">The size of buffer to use when reading</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">bufferSize is less than 1</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadFully(System.IO.Stream,MiscUtil.IBuffer)">
            <summary>
            Reads the given stream up to the end, returning the data as a byte
            array, using the given buffer for transferring data. Note that the
            current contents of the buffer is ignored, so the buffer needn't
            be cleared beforehand.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to use to transfer data</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">buffer is null</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadFully(System.IO.Stream,System.Byte[])">
            <summary>
            Reads the given stream up to the end, returning the data as a byte
            array, using the given buffer for transferring data. Note that the
            current contents of the buffer is ignored, so the buffer needn't
            be cleared beforehand.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to use to transfer data</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">buffer is null</exception>
            <exception cref="T:System.ArgumentException">buffer is a zero-length array</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.Copy(System.IO.Stream,System.IO.Stream)">
            <summary>
            Copies all the data from one stream into another.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="output">The stream to write to</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">output is null</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading or writing</exception>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.Copy(System.IO.Stream,System.IO.Stream,System.Int32)">
            <summary>
            Copies all the data from one stream into another, using a buffer
            of the given size.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="output">The stream to write to</param>
            <param name="bufferSize">The size of buffer to use when reading</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">output is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">bufferSize is less than 1</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading or writing</exception>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.Copy(System.IO.Stream,System.IO.Stream,MiscUtil.IBuffer)">
            <summary>
            Copies all the data from one stream into another, using the given 
            buffer for transferring data. Note that the current contents of 
            the buffer is ignored, so the buffer needn't be cleared beforehand.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="output">The stream to write to</param>
            <param name="buffer">The buffer to use to transfer data</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">output is null</exception>
            <exception cref="T:System.ArgumentNullException">buffer is null</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading or writing</exception>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.Copy(System.IO.Stream,System.IO.Stream,System.Byte[])">
            <summary>
            Copies all the data from one stream into another, using the given 
            buffer for transferring data. Note that the current contents of 
            the buffer is ignored, so the buffer needn't be cleared beforehand.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="output">The stream to write to</param>
            <param name="buffer">The buffer to use to transfer data</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentNullException">output is null</exception>
            <exception cref="T:System.ArgumentNullException">buffer is null</exception>
            <exception cref="T:System.ArgumentException">buffer is a zero-length array</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading or writing</exception>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,System.Int32)">
            <summary>
            Reads exactly the given number of bytes from the specified stream.
            If the end of the stream is reached before the specified amount
            of data is read, an exception is thrown.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="bytesToRead">The number of bytes to read</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">bytesToRead is less than 1</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,MiscUtil.IBuffer)">
            <summary>
            Reads into a buffer, filling it completely.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to read into</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">The buffer is of zero length</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,System.Byte[])">
            <summary>
            Reads into a buffer, filling it completely.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to read into</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">The buffer is of zero length</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,MiscUtil.IBuffer,System.Int32)">
            <summary>
            Reads into a buffer, for the given number of bytes.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to read into</param>
            <param name="bytesToRead">The number of bytes to read</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">The buffer is of zero length, or bytesToRead
            exceeds the buffer length</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,System.Byte[],System.Int32)">
            <summary>
            Reads exactly the given number of bytes from the specified stream,
            into the given buffer, starting at position 0 of the array.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The byte array to read into</param>
            <param name="bytesToRead">The number of bytes to read</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">bytesToRead is less than 1</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,MiscUtil.IBuffer,System.Int32,System.Int32)">
            <summary>
            Reads into a buffer, for the given number of bytes, from the specified location
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The buffer to read into</param>
            <param name="startIndex">The index into the buffer at which to start writing</param>
            <param name="bytesToRead">The number of bytes to read</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">The buffer is of zero length, or startIndex+bytesToRead
            exceeds the buffer length</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
            <returns>The data read from the stream</returns>
        </member>
        <member name="M:MiscUtil.IO.StreamUtil.ReadExactly(System.IO.Stream,System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads exactly the given number of bytes from the specified stream,
            into the given buffer, starting at position 0 of the array.
            </summary>
            <param name="input">The stream to read from</param>
            <param name="buffer">The byte array to read into</param>
            <param name="startIndex">The index into the buffer at which to start writing</param>
            <param name="bytesToRead">The number of bytes to read</param>
            <exception cref="T:System.ArgumentNullException">input is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">bytesToRead is less than 1, startIndex is less than 0,
            or startIndex+bytesToRead is greater than the buffer length</exception>
            <exception cref="T:System.IO.EndOfStreamException">The end of the stream is reached before 
            enough data has been read</exception>
            <exception cref="T:System.IO.IOException">An error occurs while reading from the stream</exception>
        </member>
        <member name="T:MiscUtil.Compression.Vcdiff.IOHelper">
            <summary>
            A few IO routines to make life easier. Most are basically available
            in EndianBinaryReader, but having them separately here makes VcdiffDecoder
            more easily movable to other places - and no endianness issues are involved in
            the first place.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.ProjectionComparer">
            <summary>
            Non-generic class to produce instances of the generic class,
            optionally using type inference.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer.Create``2(System.Func{``0,``1})">
            <summary>
            Creates an instance of ProjectionComparer using the specified projection.
            </summary>
            <typeparam name="TSource">Type parameter for the elements to be compared</typeparam>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer.Create``2(``0,System.Func{``0,``1})">
            <summary>
            Creates an instance of ProjectionComparer using the specified projection.
            The ignored parameter is solely present to aid type inference.
            </summary>
            <typeparam name="TSource">Type parameter for the elements to be compared</typeparam>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="ignored">Value is ignored - type may be used by type inference</param>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>
        </member>
        <member name="T:MiscUtil.Collections.ProjectionComparer`1">
            <summary>
            Class generic in the source only to produce instances of the 
            doubly generic class, optionally using type inference.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer`1.Create``1(System.Func{`0,``0})">
            <summary>
            Creates an instance of ProjectionComparer using the specified projection.
            </summary>
            <typeparam name="TKey">Type parameter for the keys to be compared, after being projected from the elements</typeparam>
            <param name="projection">Projection to use when determining the key of an element</param>
            <returns>A comparer which will compare elements by projecting each element to its key, and comparing keys</returns>        
        </member>
        <member name="T:MiscUtil.Collections.ProjectionComparer`2">
            <summary>
            Comparer which projects each element of the comparison to a key, and then compares
            those keys using the specified (or default) comparer for the key type.
            </summary>
            <typeparam name="TSource">Type of elements which this comparer will be asked to compare</typeparam>
            <typeparam name="TKey">Type of the key projected from the element</typeparam>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer`2.#ctor(System.Func{`0,`1})">
            <summary>
            Creates a new instance using the specified projection, which must not be null.
            The default comparer for the projected type is used.
            </summary>
            <param name="projection">Projection to use during comparisons</param>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer`2.#ctor(System.Func{`0,`1},System.Collections.Generic.IComparer{`1})">
            <summary>
            Creates a new instance using the specified projection, which must not be null.
            </summary>
            <param name="projection">Projection to use during comparisons</param>
            <param name="comparer">The comparer to use on the keys. May be null, in
            which case the default comparer will be used.</param>
        </member>
        <member name="M:MiscUtil.Collections.ProjectionComparer`2.Compare(`0,`0)">
            <summary>
            Compares x and y by projecting them to keys and then comparing the keys. 
            Null values are not projected; they obey the
            standard comparer contract such that two null values are equal; any null value is
            less than any non-null value.
            </summary>
        </member>
        <member name="T:MiscUtil.Operator">
            <summary>
            The Operator class provides easy access to the standard operators
            (addition, etc) for generic types, using type inference to simplify
            usage.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.HasValue``1(``0)">
            <summary>
            Indicates if the supplied value is non-null,
            for reference-types or Nullable&lt;T&gt;
            </summary>
            <returns>True for non-null values, else false</returns>
        </member>
        <member name="M:MiscUtil.Operator.AddIfNotNull``1(``0@,``0)">
            <summary>
            Increments the accumulator only
            if the value is non-null. If the accumulator
            is null, then the accumulator is given the new
            value; otherwise the accumulator and value
            are added.
            </summary>
            <param name="accumulator">The current total to be incremented (can be null)</param>
            <param name="value">The value to be tested and added to the accumulator</param>
            <returns>True if the value is non-null, else false - i.e.
            "has the accumulator been updated?"</returns>
        </member>
        <member name="M:MiscUtil.Operator.Negate``1(``0)">
            <summary>
            Evaluates unary negation (-) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Not``1(``0)">
            <summary>
            Evaluates bitwise not (~) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Or``1(``0,``0)">
            <summary>
            Evaluates bitwise or (|) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.And``1(``0,``0)">
            <summary>
            Evaluates bitwise and (&amp;) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Xor``1(``0,``0)">
            <summary>
            Evaluates bitwise xor (^) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Convert``2(``0)">
            <summary>
            Performs a conversion between the given types; this will throw
            an InvalidOperationException if the type T does not provide a suitable cast, or for
            Nullable&lt;TInner&gt; if TInner does not provide this cast.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Add``1(``0,``0)">
            <summary>
            Evaluates binary addition (+) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>        
        </member>
        <member name="M:MiscUtil.Operator.AddAlternative``2(``0,``1)">
            <summary>
            Evaluates binary addition (+) for the given type(s); this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Subtract``1(``0,``0)">
            <summary>
            Evaluates binary subtraction (-) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.SubtractAlternative``2(``0,``1)">
            <summary>
            Evaluates binary subtraction(-) for the given type(s); this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Multiply``1(``0,``0)">
            <summary>
            Evaluates binary multiplication (*) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.MultiplyAlternative``2(``0,``1)">
            <summary>
            Evaluates binary multiplication (*) for the given type(s); this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Divide``1(``0,``0)">
            <summary>
            Evaluates binary division (/) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.DivideAlternative``2(``0,``1)">
            <summary>
            Evaluates binary division (/) for the given type(s); this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.Equal``1(``0,``0)">
            <summary>
            Evaluates binary equality (==) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.NotEqual``1(``0,``0)">
            <summary>
            Evaluates binary inequality (!=) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.GreaterThan``1(``0,``0)">
            <summary>
            Evaluates binary greater-than (&gt;) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.LessThan``1(``0,``0)">
            <summary>
            Evaluates binary less-than (&lt;) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.GreaterThanOrEqual``1(``0,``0)">
            <summary>
            Evaluates binary greater-than-on-eqauls (&gt;=) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.LessThanOrEqual``1(``0,``0)">
            <summary>
            Evaluates binary less-than-or-equal (&lt;=) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="M:MiscUtil.Operator.DivideInt32``1(``0,System.Int32)">
            <summary>
            Evaluates integer division (/) for the given type; this will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary><remarks>
            This operation is particularly useful for computing averages and
            similar aggregates.
            </remarks>
        </member>
        <member name="T:MiscUtil.Operator`2">
            <summary>
            Provides standard operators (such as addition) that operate over operands of
            different types. For operators, the return type is assumed to match the first
            operand.
            </summary>
            <seealso cref="T:MiscUtil.Operator`1"/>
            <seealso cref="T:MiscUtil.Operator"/>
        </member>
        <member name="P:MiscUtil.Operator`2.Convert">
            <summary>
            Returns a delegate to convert a value between two types; this delegate will throw
            an InvalidOperationException if the type T does not provide a suitable cast, or for
            Nullable&lt;TInner&gt; if TInner does not provide this cast.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`2.Add">
            <summary>
            Returns a delegate to evaluate binary addition (+) for the given types; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`2.Subtract">
            <summary>
            Returns a delegate to evaluate binary subtraction (-) for the given types; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`2.Multiply">
            <summary>
            Returns a delegate to evaluate binary multiplication (*) for the given types; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`2.Divide">
            <summary>
            Returns a delegate to evaluate binary division (/) for the given types; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="T:MiscUtil.Operator`1">
            <summary>
            Provides standard operators (such as addition) over a single type
            </summary>
            <seealso cref="T:MiscUtil.Operator"/>
            <seealso cref="T:MiscUtil.Operator`2"/>
        </member>
        <member name="P:MiscUtil.Operator`1.Zero">
            <summary>
            Returns the zero value for value-types (even full Nullable&lt;TInner&gt;) - or null for reference types
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Negate">
            <summary>
            Returns a delegate to evaluate unary negation (-) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Not">
            <summary>
            Returns a delegate to evaluate bitwise not (~) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Or">
            <summary>
            Returns a delegate to evaluate bitwise or (|) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.And">
            <summary>
            Returns a delegate to evaluate bitwise and (&amp;) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Xor">
            <summary>
            Returns a delegate to evaluate bitwise xor (^) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Add">
            <summary>
            Returns a delegate to evaluate binary addition (+) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Subtract">
            <summary>
            Returns a delegate to evaluate binary subtraction (-) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Multiply">
            <summary>
            Returns a delegate to evaluate binary multiplication (*) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Divide">
            <summary>
            Returns a delegate to evaluate binary division (/) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.Equal">
            <summary>
            Returns a delegate to evaluate binary equality (==) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.NotEqual">
            <summary>
            Returns a delegate to evaluate binary inequality (!=) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.GreaterThan">
            <summary>
            Returns a delegate to evaluate binary greater-then (&gt;) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.LessThan">
            <summary>
            Returns a delegate to evaluate binary less-than (&lt;) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.GreaterThanOrEqual">
            <summary>
            Returns a delegate to evaluate binary greater-than-or-equal (&gt;=) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="P:MiscUtil.Operator`1.LessThanOrEqual">
            <summary>
            Returns a delegate to evaluate binary less-than-or-equal (&lt;=) for the given type; this delegate will throw
            an InvalidOperationException if the type T does not provide this operator, or for
            Nullable&lt;TInner&gt; if TInner does not provide this operator.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.Extensions.TypeExt">
            <summary>
            Provides extension methods to System.Type to provide simple
            and efficient access to delegates representing reflection
            operations.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.TypeExt.Ctor``1(System.Type)">
            <summary>
            Obtains a delegate to invoke a parameterless constructor
            </summary>
            <typeparam name="TResult">The base/interface type to yield as the
            new value; often object except for factory pattern implementations</typeparam>
            <param name="type">The Type to be created</param>
            <returns>A delegate to the constructor if found, else null</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.TypeExt.Ctor``2(System.Type)">
            <summary>
            Obtains a delegate to invoke a constructor which takes a parameter
            </summary>
            <typeparam name="TArg1">The type of the constructor parameter</typeparam>
            <typeparam name="TResult">The base/interface type to yield as the
            new value; often object except for factory pattern implementations</typeparam>
            <param name="type">The Type to be created</param>
            <returns>A delegate to the constructor if found, else null</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.TypeExt.Ctor``3(System.Type)">
            <summary>
            Obtains a delegate to invoke a constructor with multiple parameters
            </summary>
            <typeparam name="TArg1">The type of the first constructor parameter</typeparam>
            <typeparam name="TArg2">The type of the second constructor parameter</typeparam>
            <typeparam name="TResult">The base/interface type to yield as the
            new value; often object except for factory pattern implementations</typeparam>
            <param name="type">The Type to be created</param>
            <returns>A delegate to the constructor if found, else null</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.TypeExt.Ctor``4(System.Type)">
            <summary>
            Obtains a delegate to invoke a constructor with multiple parameters
            </summary>
            <typeparam name="TArg1">The type of the first constructor parameter</typeparam>
            <typeparam name="TArg2">The type of the second constructor parameter</typeparam>
            <typeparam name="TArg3">The type of the third constructor parameter</typeparam>
            <typeparam name="TResult">The base/interface type to yield as the
            new value; often object except for factory pattern implementations</typeparam>
            <param name="type">The Type to be created</param>
            <returns>A delegate to the constructor if found, else null</returns>
        </member>
        <member name="M:MiscUtil.Linq.Extensions.TypeExt.Ctor``5(System.Type)">
            <summary>
            Obtains a delegate to invoke a constructor with multiple parameters
            </summary>
            <typeparam name="TArg1">The type of the first constructor parameter</typeparam>
            <typeparam name="TArg2">The type of the second constructor parameter</typeparam>
            <typeparam name="TArg3">The type of the third constructor parameter</typeparam>
            <typeparam name="TArg4">The type of the fourth constructor parameter</typeparam>
            <typeparam name="TResult">The base/interface type to yield as the
            new value; often object except for factory pattern implementations</typeparam>
            <param name="type">The Type to be created</param>
            <returns>A delegate to the constructor if found, else null</returns>
        </member>
        <member name="T:MiscUtil.IO.LineReader">
            <summary>
            Reads a data source line by line. The source can be a file, a stream,
            or a text reader. In any case, the source is only opened when the
            enumerator is fetched, and is closed when the iterator is disposed.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.LineReader.dataSource">
            <summary>
            Means of creating a TextReader to read from.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.LineReader.#ctor(System.Func{System.IO.Stream})">
            <summary>
            Creates a LineReader from a stream source. The delegate is only
            called when the enumerator is fetched. UTF-8 is used to decode
            the stream into text.
            </summary>
            <param name="streamSource">Data source</param>
        </member>
        <member name="M:MiscUtil.IO.LineReader.#ctor(System.Func{System.IO.Stream},System.Text.Encoding)">
            <summary>
            Creates a LineReader from a stream source. The delegate is only
            called when the enumerator is fetched.
            </summary>
            <param name="streamSource">Data source</param>
            <param name="encoding">Encoding to use to decode the stream into text</param>
        </member>
        <member name="M:MiscUtil.IO.LineReader.#ctor(System.String)">
            <summary>
            Creates a LineReader from a filename. The file is only opened
            (or even checked for existence) when the enumerator is fetched.
            UTF8 is used to decode the file into text.
            </summary>
            <param name="filename">File to read from</param>
        </member>
        <member name="M:MiscUtil.IO.LineReader.#ctor(System.String,System.Text.Encoding)">
            <summary>
            Creates a LineReader from a filename. The file is only opened
            (or even checked for existence) when the enumerator is fetched.
            </summary>
            <param name="filename">File to read from</param>
            <param name="encoding">Encoding to use to decode the file into text</param>
        </member>
        <member name="M:MiscUtil.IO.LineReader.#ctor(System.Func{System.IO.TextReader})">
            <summary>
            Creates a LineReader from a TextReader source. The delegate
            is only called when the enumerator is fetched
            </summary>
            <param name="dataSource">Data source</param>
        </member>
        <member name="M:MiscUtil.IO.LineReader.GetEnumerator">
            <summary>
            Enumerates the data source line by line.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.LineReader.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Enumerates the data source line by line.
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.BigEndianBitConverter">
            <summary>
            Implementation of EndianBitConverter which converts to/from big-endian
            byte arrays.
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.EndianBitConverter">
            <summary>
            Equivalent of System.BitConverter, but with either endianness.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.IsLittleEndian">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
            <remarks>
            Different computer architectures store data using different byte orders. "Big-endian"
            means the most significant byte is on the left end of a word. "Little-endian" means the 
            most significant byte is on the right end of a word.
            </remarks>
            <returns>true if this converter is little-endian, false otherwise.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.DoubleToInt64Bits(System.Double)">
            <summary>
            Converts the specified double-precision floating point number to a 
            64-bit signed integer. Note: the endianness of this converter does not
            affect the returned value.
            </summary>
            <param name="value">The number to convert. </param>
            <returns>A 64-bit signed integer whose value is equivalent to value.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.Int64BitsToDouble(System.Int64)">
            <summary>
            Converts the specified 64-bit signed integer to a double-precision 
            floating point number. Note: the endianness of this converter does not
            affect the returned value.
            </summary>
            <param name="value">The number to convert. </param>
            <returns>A double-precision floating point number whose value is equivalent to value.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.SingleToInt32Bits(System.Single)">
            <summary>
            Converts the specified single-precision floating point number to a 
            32-bit signed integer. Note: the endianness of this converter does not
            affect the returned value.
            </summary>
            <param name="value">The number to convert. </param>
            <returns>A 32-bit signed integer whose value is equivalent to value.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.Int32BitsToSingle(System.Int32)">
            <summary>
            Converts the specified 32-bit signed integer to a single-precision floating point 
            number. Note: the endianness of this converter does not
            affect the returned value.
            </summary>
            <param name="value">The number to convert. </param>
            <returns>A single-precision floating point number whose value is equivalent to value.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToBoolean(System.Byte[],System.Int32)">
            <summary>
            Returns a Boolean value converted from one byte at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>true if the byte at startIndex in value is nonzero; otherwise, false.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToChar(System.Byte[],System.Int32)">
            <summary>
            Returns a Unicode character converted from two bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A character formed by two bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToDouble(System.Byte[],System.Int32)">
            <summary>
            Returns a double-precision floating point number converted from eight bytes 
            at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A double precision floating point number formed by eight bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToSingle(System.Byte[],System.Int32)">
            <summary>
            Returns a single-precision floating point number converted from four bytes 
            at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A single precision floating point number formed by four bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToInt16(System.Byte[],System.Int32)">
            <summary>
            Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 16-bit signed integer formed by two bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToInt32(System.Byte[],System.Int32)">
            <summary>
            Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 32-bit signed integer formed by four bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToInt64(System.Byte[],System.Int32)">
            <summary>
            Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 64-bit signed integer formed by eight bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToUInt16(System.Byte[],System.Int32)">
            <summary>
            Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 16-bit unsigned integer formed by two bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToUInt32(System.Byte[],System.Int32)">
            <summary>
            Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 32-bit unsigned integer formed by four bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToUInt64(System.Byte[],System.Int32)">
            <summary>
            Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A 64-bit unsigned integer formed by eight bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CheckByteArgument(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Checks the given argument for validity.
            </summary>
            <param name="value">The byte array passed in</param>
            <param name="startIndex">The start index passed in</param>
            <param name="bytesRequired">The number of bytes required</param>
            <exception cref="T:System.ArgumentNullException">value is a null reference</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            startIndex is less than zero or greater than the length of value minus bytesRequired.
            </exception>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CheckedFromBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Checks the arguments for validity before calling FromBytes
            (which can therefore assume the arguments are valid).
            </summary>
            <param name="value">The bytes to convert after checking</param>
            <param name="startIndex">The index of the first byte to convert</param>
            <param name="bytesToConvert">The number of bytes to convert</param>
            <returns></returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.FromBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Convert the given number of bytes from the given array, from the given start
            position, into a long, using the bytes as the least significant part of the long.
            By the time this is called, the arguments have been checked for validity.
            </summary>
            <param name="value">The bytes to convert</param>
            <param name="startIndex">The index of the first byte to convert</param>
            <param name="bytesToConvert">The number of bytes to use in the conversion</param>
            <returns>The converted number</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToString(System.Byte[])">
            <summary>
            Returns a String converted from the elements of a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <remarks>All the elements of value are converted.</remarks>
            <returns>
            A String of hexadecimal pairs separated by hyphens, where each pair 
            represents the corresponding element in value; for example, "7F-2C-4A".
            </returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToString(System.Byte[],System.Int32)">
            <summary>
            Returns a String converted from the elements of a byte array starting at a specified array position.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <remarks>The elements from array position startIndex to the end of the array are converted.</remarks>
            <returns>
            A String of hexadecimal pairs separated by hyphens, where each pair 
            represents the corresponding element in value; for example, "7F-2C-4A".
            </returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToString(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Returns a String converted from a specified number of bytes at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <param name="length">The number of bytes to convert.</param>
            <remarks>The length elements from array position startIndex are converted.</remarks>
            <returns>
            A String of hexadecimal pairs separated by hyphens, where each pair 
            represents the corresponding element in value; for example, "7F-2C-4A".
            </returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.ToDecimal(System.Byte[],System.Int32)">
            <summary>
            Returns a decimal value converted from sixteen bytes 
            at a specified position in a byte array.
            </summary>
            <param name="value">An array of bytes.</param>
            <param name="startIndex">The starting position within value.</param>
            <returns>A decimal  formed by sixteen bytes beginning at startIndex.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Decimal)">
            <summary>
            Returns the specified decimal value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 16.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Decimal,System.Byte[],System.Int32)">
            <summary>
            Copies the specified decimal value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">A character to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Int64,System.Int32)">
            <summary>
            Returns an array with the given number of bytes formed
            from the least significant bytes of the specified value.
            This is used to implement the other GetBytes methods.
            </summary>
            <param name="value">The value to get bytes for</param>
            <param name="bytes">The number of significant bytes to return</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Boolean)">
            <summary>
            Returns the specified Boolean value as an array of bytes.
            </summary>
            <param name="value">A Boolean value.</param>
            <returns>An array of bytes with length 1.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Char)">
            <summary>
            Returns the specified Unicode character value as an array of bytes.
            </summary>
            <param name="value">A character to convert.</param>
            <returns>An array of bytes with length 2.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Double)">
            <summary>
            Returns the specified double-precision floating point value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 8.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Int16)">
            <summary>
            Returns the specified 16-bit signed integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 2.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Int32)">
            <summary>
            Returns the specified 32-bit signed integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 4.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Int64)">
            <summary>
            Returns the specified 64-bit signed integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 8.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.Single)">
            <summary>
            Returns the specified single-precision floating point value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 4.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.UInt16)">
            <summary>
            Returns the specified 16-bit unsigned integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 2.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.UInt32)">
            <summary>
            Returns the specified 32-bit unsigned integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 4.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.GetBytes(System.UInt64)">
            <summary>
            Returns the specified 64-bit unsigned integer value as an array of bytes.
            </summary>
            <param name="value">The number to convert.</param>
            <returns>An array of bytes with length 8.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Int64,System.Int32,System.Byte[],System.Int32)">
            <summary>
            Copies the given number of bytes from the least-specific
            end of the specified value into the specified byte array, beginning
            at the specified index.
            This is used to implement the other CopyBytes methods.
            </summary>
            <param name="value">The value to copy bytes for</param>
            <param name="bytes">The number of significant bytes to copy</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytesImpl(System.Int64,System.Int32,System.Byte[],System.Int32)">
            <summary>
            Copies the given number of bytes from the least-specific
            end of the specified value into the specified byte array, beginning
            at the specified index.
            This must be implemented in concrete derived classes, but the implementation
            may assume that the value will fit into the buffer.
            </summary>
            <param name="value">The value to copy bytes for</param>
            <param name="bytes">The number of significant bytes to copy</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Boolean,System.Byte[],System.Int32)">
            <summary>
            Copies the specified Boolean value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">A Boolean value.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Char,System.Byte[],System.Int32)">
            <summary>
            Copies the specified Unicode character value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">A character to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Double,System.Byte[],System.Int32)">
            <summary>
            Copies the specified double-precision floating point value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Int16,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 16-bit signed integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Int32,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 32-bit signed integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Int64,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 64-bit signed integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.Single,System.Byte[],System.Int32)">
            <summary>
            Copies the specified single-precision floating point value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.UInt16,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 16-bit unsigned integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.UInt32,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 32-bit unsigned integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.CopyBytes(System.UInt64,System.Byte[],System.Int32)">
            <summary>
            Copies the specified 64-bit unsigned integer value into the specified byte array,
            beginning at the specified index.
            </summary>
            <param name="value">The number to convert.</param>
            <param name="buffer">The byte array to copy the bytes into</param>
            <param name="index">The first index into the array to copy the bytes into</param>
        </member>
        <member name="P:MiscUtil.Conversion.EndianBitConverter.Endianness">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
        </member>
        <member name="P:MiscUtil.Conversion.EndianBitConverter.Little">
            <summary>
            Returns a little-endian bit converter instance. The same instance is
            always returned.
            </summary>
        </member>
        <member name="P:MiscUtil.Conversion.EndianBitConverter.Big">
            <summary>
            Returns a big-endian bit converter instance. The same instance is
            always returned.
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion">
            <summary>
            Union used solely for the equivalent of DoubleToInt64Bits and vice versa.
            </summary>
        </member>
        <member name="F:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.i">
            <summary>
            Int32 version of the value.
            </summary>
        </member>
        <member name="F:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.f">
            <summary>
            Single version of the value.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.#ctor(System.Int32)">
            <summary>
            Creates an instance representing the given integer.
            </summary>
            <param name="i">The integer value of the new instance.</param>
        </member>
        <member name="M:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.#ctor(System.Single)">
            <summary>
            Creates an instance representing the given floating point number.
            </summary>
            <param name="f">The floating point value of the new instance.</param>
        </member>
        <member name="P:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.AsInt32">
            <summary>
            Returns the value of the instance as an integer.
            </summary>
        </member>
        <member name="P:MiscUtil.Conversion.EndianBitConverter.Int32SingleUnion.AsSingle">
            <summary>
            Returns the value of the instance as a floating point number.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.BigEndianBitConverter.IsLittleEndian">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
            <remarks>
            Different computer architectures store data using different byte orders. "Big-endian"
            means the most significant byte is on the left end of a word. "Little-endian" means the 
            most significant byte is on the right end of a word.
            </remarks>
            <returns>true if this converter is little-endian, false otherwise.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.BigEndianBitConverter.CopyBytesImpl(System.Int64,System.Int32,System.Byte[],System.Int32)">
            <summary>
            Copies the specified number of bytes from value to buffer, starting at index.
            </summary>
            <param name="value">The value to copy</param>
            <param name="bytes">The number of bytes to copy</param>
            <param name="buffer">The buffer to copy the bytes into</param>
            <param name="index">The index to start at</param>
        </member>
        <member name="M:MiscUtil.Conversion.BigEndianBitConverter.FromBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Returns a value built from the specified number of bytes from the given buffer,
            starting at index.
            </summary>
            <param name="buffer">The data in byte array format</param>
            <param name="startIndex">The first index to use</param>
            <param name="bytesToConvert">The number of bytes to use</param>
            <returns>The value built from the given bytes</returns>
        </member>
        <member name="P:MiscUtil.Conversion.BigEndianBitConverter.Endianness">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.Extensions.SmartEnumerableExt">
            <summary>
            Wrapper methods for SmartEnumerable[T].
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.Extensions.SmartEnumerableExt.AsSmartEnumerable``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Extension method to make life easier.
            </summary>
            <typeparam name="T">Type of enumerable</typeparam>
            <param name="source">Source enumerable</param>
            <returns>A new SmartEnumerable of the appropriate type</returns>
        </member>
        <member name="T:MiscUtil.ApplicationChooser">
            <summary>
            Class allowing a user to choose a console application to run, after
            examining an assembly for all classes containing a static Main method, either
            parameterless or with a string array parameter.
            </summary>
        </member>
        <member name="M:MiscUtil.ApplicationChooser.Run(System.Type,System.String[])">
            <summary>
            Displays entry points and prompts the user to choose one.
            </summary>
            <param name="type">Type within the assembly containing the applications. This type is
            not included in the list of entry points to run.</param>
            <param name="args">Arguments to pass in for methods which have a single string[] parameter.</param>
        </member>
        <member name="M:MiscUtil.ApplicationChooser.GetEntryPoint(System.Type)">
            <summary>
            Returns the entry point for a method, or null if no entry points can be used.
            An entry point taking string[] is preferred to one with no parameters.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.ReverseComparer`1">
            <summary>
            Implementation of IComparer{T} based on another one;
            this simply reverses the original comparison.
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:MiscUtil.Collections.ReverseComparer`1.#ctor(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a new reversing comparer.
            </summary>
            <param name="original">The original comparer to use for comparisons.</param>
        </member>
        <member name="M:MiscUtil.Collections.ReverseComparer`1.Compare(`0,`0)">
            <summary>
            Returns the result of comparing the specified values using the original
            comparer, but reversing the order of comparison.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.ReverseComparer`1.OriginalComparer">
            <summary>
            Returns the original comparer; this can be useful to avoid multiple
            reversals.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.DictionaryByType">
            <summary>
            Map from types to instances of those types, e.g. int to 10 and
            string to "hi" within the same dictionary. This cannot be done
            without casting (and boxing for value types) as .NET cannot
            represent this relationship with generics in their current form.
            This class encapsulates the nastiness in a single place.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.DictionaryByType.Add``1(``0)">
            <summary>
            Maps the specified type argument to the given value. If
            the type argument already has a value within the dictionary,
            ArgumentException is thrown.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.DictionaryByType.Put``1(``0)">
            <summary>
            Maps the specified type argument to the given value. If
            the type argument already has a value within the dictionary, it
            is overwritten.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.DictionaryByType.Get``1">
            <summary>
            Attempts to fetch a value from the dictionary, throwing a
            KeyNotFoundException if the specified type argument has no
            entry in the dictionary.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.DictionaryByType.TryGet``1(``0@)">
            <summary>
            Attempts to fetch a value from the dictionary, returning false and
            setting the output parameter to the default value for T if it
            fails, or returning true and setting the output parameter to the
            fetched value if it succeeds.
            </summary>
        </member>
        <member name="T:MiscUtil.Text.Utf32String">
            <summary>
            String of UTF-32 characters (ints). This class is immutable, and so is thread-safe
            after copying, but copies must be originally made in a thread-safe manner so as
            to avoid seeing invalid data.
            </summary>
        </member>
        <member name="F:MiscUtil.Text.Utf32String.HashcodeSampleSize">
            <summary>
            Number of samples to take (at most) to form a hash code.
            </summary>
        </member>
        <member name="F:MiscUtil.Text.Utf32String.Empty">
            <summary>
            An empty UTF-32 string.
            </summary>
        </member>
        <member name="F:MiscUtil.Text.Utf32String.characters">
            <summary>
            UTF-32 characters making up the string.
            </summary>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IsValidUtf32Char(System.Int32)">
            <summary>
            Returns whether or not an integer value is a valid
            UTF-32 character, that is, whether it is non-negative
            and less than or equal to 0x10ffff.
            </summary>
            <param name="value">The value to test.</param>
            <returns>Whether or not the given value is a valid UTF-32 character.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.#ctor(System.Int32[],System.Boolean)">
            <summary>
            Used inside this class to construct extra strings quickly, when validation
            isn't required and a reference copy is good enough.
            </summary>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.#ctor(System.Int32[])">
            <summary>
            Creates a UTF-32 string from an array of integers, all of which must
            be less than 0x10ffff and non-negative. A copy of the array is taken so that
            further changes to the array afterwards are ignored.
            </summary>
            <param name="characters">The array of characters to copy. Must not be null.</param>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.#ctor(System.String)">
            <summary>
            Creates a UTF-32 string from a System.String (UTF-16), converting surrogates
            where they are present.
            </summary>
            <param name="utf16">The string in UTF-16 format.</param>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Substring(System.Int32)">
            <summary>
            Takes a substring of this string, starting at the given index.
            </summary>
            <param name="start">Starting index of desired substring in this string</param>
            <returns>A substring of this string</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Substring(System.Int32,System.Int32)">
            <summary>
            Takes a substring of this string, starting at the given index
            and containing the given number of characters.
            </summary>
            <param name="start">Starting index of desired substring in this string</param>
            <param name="count">The number of characters in the desired substring</param>
            <returns>A substring of this string</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(MiscUtil.Text.Utf32String)">
            <summary>
            Finds the index of another Utf32String within this one.
            </summary>
            <param name="value">Value to find</param>
            <returns>The index of value within this string, or -1 if it isn't found</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(MiscUtil.Text.Utf32String,System.Int32)">
            <summary>
            Finds the index of another Utf32String within this one,
            starting at the specified position.
            </summary>
            <param name="value">Value to find</param>
            <param name="start">First position to consider when finding value within this Utf32String</param>
            <returns>The index of value within this string, or -1 if it isn't found</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(MiscUtil.Text.Utf32String,System.Int32,System.Int32)">
            <summary>
            Finds the index of another Utf32String within this one,
            starting at the specified position and considering the
            specified number of positions.
            </summary>
            <param name="value">Value to find</param>
            <param name="start">First position to consider when finding value within this Utf32String</param>
            <param name="count">Number of positions to consider</param>
            <returns>The index of value within this string, or -1 if it isn't found</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(System.Int32)">
            <summary>
            Finds the first index of the specified character within this string.
            </summary>
            <param name="character">Character to find</param>
            <returns>The index of the first occurrence of the specified character, or -1
            if it is not found.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(System.Int32,System.Int32)">
            <summary>
            Finds the first index of the specified character within this string, starting
            at the specified position.
            </summary>
            <param name="character">Character to find</param>
            <param name="start">First position to consider</param>
            <returns>The index of the first occurrence of the specified character, or -1
            if it is not found.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.IndexOf(System.Int32,System.Int32,System.Int32)">
            <summary>
            Finds the first index of the specified character within this string, starting
            at the specified position and considering the specified number of positions.
            </summary>
            <param name="character">Character to find</param>
            <param name="start">First position to consider</param>
            <param name="count">Number of positions to consider</param>
            <returns>The index of the first occurrence of the specified character, or -1
            if it is not found.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Equals(MiscUtil.Text.Utf32String)">
            <summary>
            Compares two UTF-32 strings (in a culture-insensitive manner) for equality.
            </summary>
            <param name="other">The other string to compare this one to.</param>
            <returns>Whether or not this string is equal to the other one.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Equals(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Compares one string with another for equality.
            </summary>
            <param name="strA">The first string to compare</param>
            <param name="strB">The second string to compare</param>
            <returns>true if the strings are equivalent; false otherwise</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Compare(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Compares the two specified strings.
            </summary>
            <param name="strA">The first string to compare</param>
            <param name="strB">The second string to compare</param>
            <returns>0 if both strings are null or they are equal; a negative number if strA is null or
            is lexicographically before strB; a positive number otherwise</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Concat(MiscUtil.Text.Utf32String[])">
            <summary>
            Concatenates an array of strings together.
            </summary>
            <param name="strings">The array of strings to concatenate.</param>
            <returns></returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Concat(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Returns a concatenation of the given strings.
            </summary>
            <param name="strA">The first string</param>
            <param name="strB">The second string</param>
            <returns>A string consisting of the first string followed by the second</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Concat(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Returns a concatenation of the given strings.
            </summary>
            <param name="strA">The first string</param>
            <param name="strB">The second string</param>
            <param name="strC">The third string</param>
            <returns>
            A string consisting of the first string 
            followed by the second, followed by the third
            </returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Concat(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Returns a concatenation of the given strings.
            </summary>
            <param name="strA">The first string</param>
            <param name="strB">The second string</param>
            <param name="strC">The third string</param>
            <param name="strD">The fourth string</param>
            <returns>
            A string consisting of the first string 
            followed by the second, followed by the third,
            followed by the fourth
            </returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.ToInt32Array">
            <summary>
            Copies the UTF-32 characters in this string to an int array.
            </summary>
            <returns>An array of integers representing the characters in this array.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.ToString">
            <summary>
            Converts the UTF-32 string into a UTF-16 string, 
            creating surrogates if necessary.
            </summary>
            <returns>
            A UTF-16 string (System.String) representing the same 
            character data as this UTF-32 string.
            </returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Equals(System.Object)">
            <summary>
            Returns whether or not this UTF-32 string is equal to another object.
            </summary>
            <param name="obj">The object to compare this UTF-32 string to.</param>
            <returns>Whether or not this object is equal to the other one.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.GetHashCode">
            <summary>
            Returns a hashcode formed from sampling some of the characters in this
            UTF-32 string. This gives a good balance between performance and hash
            collisions.
            </summary>
            <returns>A hashcode for this UTF-32 string.</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.op_Addition(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Returns a concatenation of the given strings.
            </summary>
            <param name="strA">The first string</param>
            <param name="strB">The second string</param>
            <returns>A string consisting of the first string followed by the second</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.op_Equality(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Determines whether two specified String objects have the same value.
            </summary>
            <param name="strA">A string or a null reference</param>
            <param name="strB">A string or a null reference</param>
            <returns>true if the value of strA is the same as the value of strB; otherwise, false</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.op_Inequality(MiscUtil.Text.Utf32String,MiscUtil.Text.Utf32String)">
            <summary>
            Determines whether two specified String objects have different values.
            </summary>
            <param name="strA">A string or a null reference</param>
            <param name="strB">A string or a null reference</param>
            <returns>true if the value of strA is different from the value of strB; otherwise, false</returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.GetEnumerator">
            <summary>
            Enumerates the characters in the string.
            </summary>
            <returns>The enumerator for </returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.CompareTo(System.Object)">
            <summary>
            Compares this string to another Utf32String.
            </summary>
            <param name="obj">The other Utf32String to compare this string to.</param>
            <returns>
            &lt;0 if this string &lt;> obj; 0 if this==object; &gt;0 if this string &gt; obj, 
            with the relation defines in a culture-insensitive way in lexicographic order.
            </returns>
        </member>
        <member name="M:MiscUtil.Text.Utf32String.Clone">
            <summary>
            Creates a shallow copy of this string.
            </summary>
            <returns>A shallow copy of this string.</returns>
        </member>
        <member name="P:MiscUtil.Text.Utf32String.Length">
            <summary>
            The number of UTF-32 characters in this string.
            </summary>
        </member>
        <member name="P:MiscUtil.Text.Utf32String.Item(System.Int32)">
            <summary>
            The character at the specified index.
            </summary>
        </member>
        <member name="T:MiscUtil.NonNullable`1">
            <summary>
            Encapsulates a reference compatible with the type parameter. The reference
            is guaranteed to be non-null unless the value has been created with the
            parameterless constructor (e.g. as the default value of a field or array).
            Implicit conversions are available to and from the type parameter. The
            conversion to the non-nullable type will throw ArgumentNullException
            when presented with a null reference. The conversion from the non-nullable
            type will throw NullReferenceException if it contains a null reference.
            This type is a value type (to avoid taking any extra space) and as the CLR
            unfortunately has no knowledge of it, it will be boxed as any other value
            type. The conversions are also available through the Value property and the
            parameterised constructor.
            </summary>
            <typeparam name="T">Type of non-nullable reference to encapsulate</typeparam>
        </member>
        <member name="M:MiscUtil.NonNullable`1.#ctor(`0)">
            <summary>
            Creates a non-nullable value encapsulating the specified reference.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.op_Implicit(`0)~MiscUtil.NonNullable{`0}">
            <summary>
            Implicit conversion from the specified reference.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.op_Implicit(MiscUtil.NonNullable{`0})~`0">
            <summary>
            Implicit conversion to the type parameter from the encapsulated value.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.op_Equality(MiscUtil.NonNullable{`0},MiscUtil.NonNullable{`0})">
            <summary>
            Equality operator, which performs an identity comparison on the encapuslated
            references. No exception is thrown even if the references are null.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.op_Inequality(MiscUtil.NonNullable{`0},MiscUtil.NonNullable{`0})">
            <summary>
            Inequality operator, which performs an identity comparison on the encapuslated
            references. No exception is thrown even if the references are null.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.Equals(System.Object)">
            <summary>
            Equality is deferred to encapsulated references, but there is no equality
            between a NonNullable[T] and a T. This method never throws an exception,
            even if a null reference is encapsulated.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.Equals(MiscUtil.NonNullable{`0})">
            <summary>
            Type-safe (and non-boxing) equality check.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.Equals(MiscUtil.NonNullable{`0},MiscUtil.NonNullable{`0})">
            <summary>
            Type-safe (and non-boxing) static equality check.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.GetHashCode">
            <summary>
            Defers to the GetHashCode implementation of the encapsulated reference, or 0 if
            the reference is null.
            </summary>
        </member>
        <member name="M:MiscUtil.NonNullable`1.ToString">
            <summary>
            Defers to the ToString implementation of the encapsulated reference, or an
            empty string if the reference is null.
            </summary>
        </member>
        <member name="P:MiscUtil.NonNullable`1.Value">
            <summary>
            Retrieves the encapsulated value, or throws a NullReferenceException if
            this instance was created with the parameterless constructor or by default.
            </summary>
        </member>
        <member name="T:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt">
            <summary>
            Extension methods producing DateTime values. These are useful
            when writing unit tests with fixed dates which should be easily understandable.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.January(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in January
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.February(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in February
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.March(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in March
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.April(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in April
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.May(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in May
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.June(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in June
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.July(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in July
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.August(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in August
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.September(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in September
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.October(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in October
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.November(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in November
            in the specified year.
            </summary>
        </member>
        <member name="M:MiscUtil.Extensions.TimeRelated.DateTimeBasedExt.December(System.Int32,System.Int32)">
            <summary>
            Returns a DateTime representing the specified day in December
            in the specified year.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.SmartEnumerable">
            <summary>
            Static class to make creation easier. If possible though, use the extension
            method in SmartEnumerableExt.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.SmartEnumerable.Create``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Extension method to make life easier.
            </summary>
            <typeparam name="T">Type of enumerable</typeparam>
            <param name="source">Source enumerable</param>
            <returns>A new SmartEnumerable of the appropriate type</returns>
        </member>
        <member name="T:MiscUtil.Collections.SmartEnumerable`1">
            <summary>
            Type chaining an IEnumerable&lt;T&gt; to allow the iterating code
            to detect the first and last entries simply.
            </summary>
            <typeparam name="T">Type to iterate over</typeparam>
        </member>
        <member name="F:MiscUtil.Collections.SmartEnumerable`1.enumerable">
            <summary>
            Enumerable we proxy to
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.SmartEnumerable`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Constructor.
            </summary>
            <param name="enumerable">Collection to enumerate. Must not be null.</param>
        </member>
        <member name="M:MiscUtil.Collections.SmartEnumerable`1.GetEnumerator">
            <summary>
            Returns an enumeration of Entry objects, each of which knows
            whether it is the first/last of the enumeration, as well as the
            current value.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.SmartEnumerable`1.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            Non-generic form of GetEnumerator.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.SmartEnumerable`1.Entry">
            <summary>
            Represents each entry returned within a collection,
            containing the value and whether it is the first and/or
            the last entry in the collection's. enumeration
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.SmartEnumerable`1.Entry.Value">
            <summary>
            The value of the entry.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.SmartEnumerable`1.Entry.IsFirst">
            <summary>
            Whether or not this entry is first in the collection's enumeration.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.SmartEnumerable`1.Entry.IsLast">
            <summary>
            Whether or not this entry is last in the collection's enumeration.
            </summary>
        </member>
        <member name="P:MiscUtil.Collections.SmartEnumerable`1.Entry.Index">
            <summary>
            The 0-based index of this entry (i.e. how many entries have been returned before this one)
            </summary>
        </member>
        <member name="T:MiscUtil.Xml.Linq.Extensions.ObjectExt">
            <summary>
            Extensions to System.Object for LINQ to XML purposes.
            </summary>
        </member>
        <member name="M:MiscUtil.Xml.Linq.Extensions.ObjectExt.AsXElements(System.Object)">
            <summary>
            Returns the properties of the given object as XElements.
            Properties with null values are still returned, but as empty
            elements. Underscores in property names are replaces with hyphens.
            </summary>
        </member>
        <member name="M:MiscUtil.Xml.Linq.Extensions.ObjectExt.AsXAttributes(System.Object)">
            <summary>
            Returns the properties of the given object as XElements.
            Properties with null values are returned as empty attributes.
            Underscores in property names are replaces with hyphens.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.KeyValueTuple`2">
            <summary>
            Generic tuple for a key and a single value
            </summary>
            <typeparam name="TKey">The Type of the key</typeparam>
            <typeparam name="T">The Type of the value</typeparam>
        </member>
        <member name="M:MiscUtil.Linq.KeyValueTuple`2.#ctor(`0,`1)">
            <summary>
            Creates a new tuple with the given key and value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`2.Key">
            <summary>
            The key for the tuple
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`2.Value">
            <summary>
            The value for the tuple
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.KeyValueTuple`3">
            <summary>
            Generic tuple for a key and a pair of values
            </summary>
            <typeparam name="TKey">The Type of the key</typeparam>
            <typeparam name="T1">The Type of the first value</typeparam>
            <typeparam name="T2">The Type of the second value</typeparam>    
        </member>
        <member name="M:MiscUtil.Linq.KeyValueTuple`3.#ctor(`0,`1,`2)">
            <summary>
            Creates a new tuple with the given key and values
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`3.Key">
            <summary>
            The key for the tuple
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`3.Value1">
            <summary>
            The first value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`3.Value2">
            <summary>
            The second value
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.KeyValueTuple`4">
            <summary>
            Generic tuple for a key and a trio of values
            </summary>
            <typeparam name="TKey">The Type of the key</typeparam>
            <typeparam name="T1">The Type of the first value</typeparam>
            <typeparam name="T2">The Type of the second value</typeparam>
            <typeparam name="T3">The Type of the third value</typeparam>
        </member>
        <member name="M:MiscUtil.Linq.KeyValueTuple`4.#ctor(`0,`1,`2,`3)">
            <summary>
            Creates a new tuple with the given key and values
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`4.Key">
            <summary>
            The key for the tuple
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`4.Value1">
            <summary>
            The first value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`4.Value2">
            <summary>
            The second value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`4.Value3">
            <summary>
            The third value
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.KeyValueTuple`5">
            <summary>
            Generic tuple for a key and a quartet of values
            </summary>
            <typeparam name="TKey">The Type of the key</typeparam>
            <typeparam name="T1">The Type of the first value</typeparam>
            <typeparam name="T2">The Type of the second value</typeparam>
            <typeparam name="T3">The Type of the third value</typeparam>
            <typeparam name="T4">The Type of the fourth value</typeparam>
        </member>
        <member name="M:MiscUtil.Linq.KeyValueTuple`5.#ctor(`0,`1,`2,`3,`4)">
            <summary>
            Creates a new tuple with the given key and values
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`5.Key">
            <summary>
            The key for the tuple
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`5.Value1">
            <summary>
            The first value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`5.Value2">
            <summary>
            The second value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`5.Value3">
            <summary>
            The third value
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.KeyValueTuple`5.Value4">
            <summary>
            The fourth value
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.Future`1">
            <summary>
            Poor-man's version of a Future. This wraps a result which *will* be
            available in the future. It's up to the caller/provider to make sure
            that the value has been specified by the time it's requested.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.IFuture`1">
            <summary>
            Class representing a value which will be available some time in the future.
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.IFuture`1.Value">
            <summary>
            Retrieves the value, if available, and throws InvalidOperationException
            otherwise.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.Future`1.ToString">
            <summary>
            Returns a string representation of the value if available, null otherwise
            </summary>
            <returns>A string representation of the value if available, null otherwise</returns>
        </member>
        <member name="P:MiscUtil.Linq.Future`1.Value">
            <summary>
            Returns the value of the future, once it has been set
            </summary>
            <exception cref="T:System.InvalidOperationException">If the value is not yet available</exception>
        </member>
        <member name="T:MiscUtil.Threading.OrderedLock">
            <summary>
            Class used for locking, as an alternative to just locking on normal monitors.
            Allows for timeouts when locking, and each Lock method returns a token which
            must then be disposed of to release the internal monitor (i.e. to unlock).
            All properties and methods of this class are thread-safe.
            </summary>
        </member>
        <member name="F:MiscUtil.Threading.OrderedLock.count">
            <summary>
            Lock count (incremented with Lock, decremented with Unlock).
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.#ctor">
            <summary>
            Creates a new lock with no name, and the default timeout specified by DefaultDefaultTimeout.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.#ctor(System.String)">
            <summary>
            Creates a new lock with the specified name, and the default timeout specified by
            DefaultDefaultTimeout.
            </summary>
            <param name="name">The name of the new lock</param>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.#ctor(System.Int32)">
            <summary>
            Creates a new lock with no name, and the specified default timeout
            </summary>
            <param name="defaultTimeout">Default timeout, in milliseconds</param>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.#ctor(System.String,System.Int32)">
            <summary>
            Creates a new lock with the specified name, and an
            infinite default timeout.
            </summary>
            <param name="name">The name of the new lock</param>
            <param name="defaultTimeout">
            Default timeout, in milliseconds. Use Timeout.Infinite
            for an infinite timeout, or a non-negative number otherwise.
            </param>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.SetInnerLock(MiscUtil.Threading.OrderedLock)">
            <summary>
            Sets the "inner" lock for this lock, returning this lock. This
            is a convenience method for setting InnerLock as part of a variable
            declaration.
            </summary>
            <example>
            OrderedLock inner = new OrderedLock();
            OrderedLock outer = new OrderedLock().SetInnerLock(inner);
            </example>
            <param name="inner">The inner </param>
            <returns>This lock is returned.</returns>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.Lock(System.Int32)">
            <summary>
            Locks the monitor, with the specified timeout. This implementation validates
            the ordering of locks, and maintains the current owner.
            </summary>
            <param name="timeout">The timeout, in milliseconds. Must be Timeout.Infinite,
            or non-negative.</param>
            <returns>A lock token which should be disposed to release the lock</returns>
            <exception cref="T:MiscUtil.Threading.LockTimeoutException">The operation times out.</exception>
            <exception cref="T:MiscUtil.Threading.LockOrderException">
            The lock order would be violated if this lock were taken out. (i.e. attempting
            to acquire the lock could cause deadlock.)
            </exception>
        </member>
        <member name="M:MiscUtil.Threading.OrderedLock.Unlock">
            <summary>
            Unlocks the monitor, decreasing the count and setting the owner to null
            if the count becomes 0.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.OrderedLock.Owner">
            <summary>
            The current owner of the lock, if any.
            </summary>
        </member>
        <member name="P:MiscUtil.Threading.OrderedLock.InnerLock">
            <summary>
            Gets or sets the "inner" lock for this lock. This lock must not be acquired
            after the inner one, unless it has already been acquired previously.
            Inner locks are transitive - if A has an inner lock B, and B has
            an inner lock C, then C is also effectively an inner lock of A.
            If this property to null, this lock is considered not to have an inner lock.
            </summary>
        </member>
        <member name="T:MiscUtil.Threading.LockTimeoutException">
            <summary>
            Exception thrown when a Lock method on the SyncLock class times out.
            </summary>
        </member>
        <member name="M:MiscUtil.Threading.LockTimeoutException.#ctor(System.String)">
            <summary>
            Constructs an instance with the specified message.
            </summary>
            <param name="message">The message for the exception</param>
        </member>
        <member name="M:MiscUtil.Threading.LockTimeoutException.#ctor(System.String,System.Object[])">
            <summary>
            Constructs an instance by formatting the specified message with
            the given parameters.
            </summary>
            <param name="format">The message, which will be formatted with the parameters.</param>
            <param name="args">The parameters to use for formatting.</param>
        </member>
        <member name="T:MiscUtil.StaticRandom">
            <summary>
            Thread-safe equivalent of System.Random, using just static methods.
            If all you want is a source of random numbers, this is an easy class to
            use. If you need to specify your own seeds (eg for reproducible sequences
            of numbers), use System.Random.
            </summary>
        </member>
        <member name="M:MiscUtil.StaticRandom.Next">
            <summary>
            Returns a nonnegative random number. 
            </summary>		
            <returns>A 32-bit signed integer greater than or equal to zero and less than Int32.MaxValue.</returns>
        </member>
        <member name="M:MiscUtil.StaticRandom.Next(System.Int32)">
            <summary>
            Returns a nonnegative random number less than the specified maximum. 
            </summary>
            <returns>
            A 32-bit signed integer greater than or equal to zero, and less than maxValue; 
            that is, the range of return values includes zero but not maxValue.
            </returns>
            <exception cref="T:System.ArgumentOutOfRangeException">maxValue is less than zero.</exception>
        </member>
        <member name="M:MiscUtil.StaticRandom.Next(System.Int32,System.Int32)">
            <summary>
            Returns a random number within a specified range. 
            </summary>
            <param name="min">The inclusive lower bound of the random number returned. </param>
            <param name="max">
            The exclusive upper bound of the random number returned. 
            maxValue must be greater than or equal to minValue.
            </param>
            <returns>
            A 32-bit signed integer greater than or equal to minValue and less than maxValue;
            that is, the range of return values includes minValue but not maxValue.
            If minValue equals maxValue, minValue is returned.
            </returns>
            <exception cref="T:System.ArgumentOutOfRangeException">minValue is greater than maxValue.</exception>
        </member>
        <member name="M:MiscUtil.StaticRandom.NextDouble">
            <summary>
            Returns a random number between 0.0 and 1.0.
            </summary>
            <returns>A double-precision floating point number greater than or equal to 0.0, and less than 1.0.</returns>
        </member>
        <member name="M:MiscUtil.StaticRandom.NextBytes(System.Byte[])">
            <summary>
            Fills the elements of a specified array of bytes with random numbers.
            </summary>
            <param name="buffer">An array of bytes to contain random numbers.</param>
            <exception cref="T:System.ArgumentNullException">buffer is a null reference (Nothing in Visual Basic).</exception>
        </member>
        <member name="T:MiscUtil.Collections.LinkedComparer`1">
            <summary>
            Comparer to daisy-chain two existing comparers and 
            apply in sequence (i.e. sort by x then y)
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:MiscUtil.Collections.LinkedComparer`1.#ctor(System.Collections.Generic.IComparer{`0},System.Collections.Generic.IComparer{`0})">
            <summary>
            Create a new LinkedComparer
            </summary>
            <param name="primary">The first comparison to use</param>
            <param name="secondary">The next level of comparison if the primary returns 0 (equivalent)</param>
        </member>
        <member name="T:MiscUtil.IO.ReverseLineReader">
            <summary>
            Takes an encoding (defaulting to UTF-8) and a function which produces a seekable stream
            (or a filename for convenience) and yields lines from the end of the stream backwards.
            Only single byte encodings, and UTF-8 and Unicode, are supported. The stream
            returned by the function must be seekable.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.ReverseLineReader.DefaultBufferSize">
            <summary>
            Buffer size to use by default. Classes with internal access can specify
            a different buffer size - this is useful for testing.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.ReverseLineReader.streamSource">
            <summary>
            Means of creating a Stream to read from.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.ReverseLineReader.encoding">
            <summary>
            Encoding to use when converting bytes to text
            </summary>
        </member>
        <member name="F:MiscUtil.IO.ReverseLineReader.bufferSize">
            <summary>
            Size of buffer (in bytes) to read each time we read from the
            stream. This must be at least as big as the maximum number of
            bytes for a single character.
            </summary>
        </member>
        <member name="F:MiscUtil.IO.ReverseLineReader.characterStartDetector">
            <summary>
            Function which, when given a position within a file and a byte, states whether
            or not the byte represents the start of a character.
            </summary>
        </member>
        <member name="M:MiscUtil.IO.ReverseLineReader.#ctor(System.Func{System.IO.Stream})">
            <summary>
            Creates a LineReader from a stream source. The delegate is only
            called when the enumerator is fetched. UTF-8 is used to decode
            the stream into text.
            </summary>
            <param name="streamSource">Data source</param>
        </member>
        <member name="M:MiscUtil.IO.ReverseLineReader.#ctor(System.String)">
            <summary>
            Creates a LineReader from a filename. The file is only opened
            (or even checked for existence) when the enumerator is fetched.
            UTF8 is used to decode the file into text.
            </summary>
            <param name="filename">File to read from</param>
        </member>
        <member name="M:MiscUtil.IO.ReverseLineReader.#ctor(System.String,System.Text.Encoding)">
            <summary>
            Creates a LineReader from a filename. The file is only opened
            (or even checked for existence) when the enumerator is fetched.
            </summary>
            <param name="filename">File to read from</param>
            <param name="encoding">Encoding to use to decode the file into text</param>
        </member>
        <member name="M:MiscUtil.IO.ReverseLineReader.#ctor(System.Func{System.IO.Stream},System.Text.Encoding)">
            <summary>
            Creates a LineReader from a stream source. The delegate is only
            called when the enumerator is fetched.
            </summary>
            <param name="streamSource">Data source</param>
            <param name="encoding">Encoding to use to decode the stream into text</param>
        </member>
        <member name="M:MiscUtil.IO.ReverseLineReader.GetEnumerator">
            <summary>
            Returns the enumerator reading strings backwards. If this method discovers that
            the returned stream is either unreadable or unseekable, a NotSupportedException is thrown.
            </summary>
        </member>
        <member name="T:MiscUtil.Collections.ComparisonComparer`1">
            <summary>
            Utility to build an IComparer implementation from a Comparison delegate,
            and a static method to do the reverse.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ComparisonComparer`1.#ctor(System.Comparison{`0})">
            <summary>
            Creates a new instance which will proxy to the given Comparison
            delegate when called.
            </summary>
            <param name="comparison">Comparison delegate to proxy to. Must not be null.</param>
        </member>
        <member name="M:MiscUtil.Collections.ComparisonComparer`1.Compare(`0,`0)">
            <summary>
            Implementation of IComparer.Compare which simply proxies
            to the originally specified Comparison delegate.
            </summary>
        </member>
        <member name="M:MiscUtil.Collections.ComparisonComparer`1.CreateComparison(System.Collections.Generic.IComparer{`0})">
            <summary>
            Creates a Comparison delegate from the given Comparer.
            </summary>
            <param name="comparer">Comparer to use when the returned delegate is called. Must not be null.</param>
            <returns>A Comparison delegate which proxies to the given Comparer.</returns>
        </member>
        <member name="T:MiscUtil.Reflection.PropertyCopy`1">
            <summary>
            Generic class which copies to its target type from a source
            type specified in the Copy method. The types are specified
            separately to take advantage of type inference on generic
            method arguments.
            </summary>
        </member>
        <member name="M:MiscUtil.Reflection.PropertyCopy`1.CopyFrom``1(``0)">
            <summary>
            Copies all readable properties from the source to a new instance
            of TTarget.
            </summary>
        </member>
        <member name="T:MiscUtil.Reflection.PropertyCopy`1.PropertyCopier`1">
            <summary>
            Static class to efficiently store the compiled delegate which can
            do the copying. We need a bit of work to ensure that exceptions are
            appropriately propagated, as the exception is generated at type initialization
            time, but we wish it to be thrown as an ArgumentException.
            </summary>
        </member>
        <member name="T:MiscUtil.Linq.FutureProxy`1">
            <summary>
            Implementation of IFuture which retrieves it value from a delegate.
            This is primarily used for FromFuture, which will transform another
            Future's value on demand.
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.FutureProxy`1.#ctor(System.Func{`0})">
            <summary>
            Creates a new FutureProxy using the given method
            to obtain the value when needed
            </summary>
        </member>
        <member name="M:MiscUtil.Linq.FutureProxy`1.FromFuture``1(MiscUtil.Linq.IFuture{``0},System.Func{``0,`0})">
            <summary>
            Creates a new FutureProxy from an existing future using
            the supplied transformation to obtain the value as needed
            </summary>
        </member>
        <member name="P:MiscUtil.Linq.FutureProxy`1.Value">
            <summary>
            Returns the value of the Future
            </summary>
        </member>
        <member name="T:MiscUtil.Conversion.LittleEndianBitConverter">
            <summary>
            Implementation of EndianBitConverter which converts to/from little-endian
            byte arrays.
            </summary>
        </member>
        <member name="M:MiscUtil.Conversion.LittleEndianBitConverter.IsLittleEndian">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
            <remarks>
            Different computer architectures store data using different byte orders. "Big-endian"
            means the most significant byte is on the left end of a word. "Little-endian" means the 
            most significant byte is on the right end of a word.
            </remarks>
            <returns>true if this converter is little-endian, false otherwise.</returns>
        </member>
        <member name="M:MiscUtil.Conversion.LittleEndianBitConverter.CopyBytesImpl(System.Int64,System.Int32,System.Byte[],System.Int32)">
            <summary>
            Copies the specified number of bytes from value to buffer, starting at index.
            </summary>
            <param name="value">The value to copy</param>
            <param name="bytes">The number of bytes to copy</param>
            <param name="buffer">The buffer to copy the bytes into</param>
            <param name="index">The index to start at</param>
        </member>
        <member name="M:MiscUtil.Conversion.LittleEndianBitConverter.FromBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Returns a value built from the specified number of bytes from the given buffer,
            starting at index.
            </summary>
            <param name="buffer">The data in byte array format</param>
            <param name="startIndex">The first index to use</param>
            <param name="bytesToConvert">The number of bytes to use</param>
            <returns>The value built from the given bytes</returns>
        </member>
        <member name="P:MiscUtil.Conversion.LittleEndianBitConverter.Endianness">
            <summary>
            Indicates the byte order ("endianess") in which data is converted using this class.
            </summary>
        </member>
    </members>
</doc>
